diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 95b667ac946..60744cadbf7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -19,6 +19,9 @@ on:
       MSRV:
         required: true
         type: string
+      verbose:
+        type: boolean
+        default: false
 
 jobs:
   build:
@@ -27,6 +30,15 @@ jobs:
     if: ${{ !(startsWith(inputs.python-version, 'graalpy') && startsWith(inputs.os, 'windows')) }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          # For PRs, we need to run on the real PR head, not the resultant merge of the PR into the target branch.
+          #
+          # This is necessary for coverage reporting to make sense; we then get exactly the coverage change
+          # between the base branch and the real PR head.
+          #
+          # If it were run on the merge commit the problem is that the coverage potentially does not align
+          # with the commit diff, because the merge may affect line numbers.
+          ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.sha }}
 
       - name: Set up Python ${{ inputs.python-version }}
         uses: actions/setup-python@v5
@@ -40,17 +52,26 @@ jobs:
       - name: Install nox
         run: python -m pip install --upgrade pip && pip install nox
 
-      - if: inputs.python-version == 'graalpy24.1'
-        name: Install GraalPy virtualenv (only GraalPy 24.1)
-        run: python -m pip install 'git+https://github.com/oracle/graalpython#egg=graalpy_virtualenv_seeder&subdirectory=graalpy_virtualenv_seeder'
-
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ inputs.rust }}
           targets: ${{ inputs.rust-target }}
-          # needed to correctly format errors, see #1865
-          components: rust-src
+          # rust-src needed to correctly format errors, see #1865
+          components: rust-src,llvm-tools-preview
+
+      # On windows 32 bit, we are running on an x64 host, so we need to specifically set the target
+      # NB we don't do this for *all* jobs because it breaks coverage of proc macros to have an
+      # explicit target set.
+      - name: Set Rust target for Windows 32-bit
+        if: inputs.os == 'windows-latest' && inputs.python-architecture == 'x86'
+        shell: bash
+        run: |
+          echo "CARGO_BUILD_TARGET=i686-pc-windows-msvc" >> $GITHUB_ENV
+
+      - name: Install zoneinfo backport for Python 3.7 / 3.8
+        if: contains(fromJSON('["3.7", "3.8"]'), inputs.python-version)
+        run: python -m pip install backports.zoneinfo
 
       - uses: Swatinem/rust-cache@v2
         with:
@@ -68,80 +89,12 @@ jobs:
         name: Ignore changed error messages when using trybuild
         run: echo "TRYBUILD=overwrite" >> "$GITHUB_ENV"
 
-      - if: inputs.rust == 'nightly'
-        name: Prepare to test on nightly rust
-        run: echo "MAYBE_NIGHTLY=nightly" >> "$GITHUB_ENV"
-
-      - name: Build docs
-        run: nox -s docs
-
-      - name: Build (no features)
-        if: ${{ !startsWith(inputs.python-version, 'graalpy') }}
-        run: cargo build --lib --tests --no-default-features
-
-      # --no-default-features when used with `cargo build/test -p` doesn't seem to work!
-      - name: Build pyo3-build-config (no features)
-        run: |
-          cd pyo3-build-config
-          cargo build --no-default-features
-
-      # Run tests (except on PyPy, because no embedding API).
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') && !startsWith(inputs.python-version, 'graalpy') }}
-        name: Test (no features)
-        run: cargo test --no-default-features --lib --tests
-
-      # --no-default-features when used with `cargo build/test -p` doesn't seem to work!
-      - name: Test pyo3-build-config (no features)
-        run: |
-          cd pyo3-build-config
-          cargo test --no-default-features
-
-      - name: Build (all additive features)
-        if: ${{ !startsWith(inputs.python-version, 'graalpy') }}
-        run: cargo build --lib --tests --no-default-features --features "multiple-pymethods full $MAYBE_NIGHTLY"
-
-      - if: ${{ startsWith(inputs.python-version, 'pypy') }}
-        name: Build PyPy (abi3-py39)
-        run: cargo build --lib --tests --no-default-features --features "multiple-pymethods abi3-py39 full $MAYBE_NIGHTLY"
-
-      # Run tests (except on PyPy, because no embedding API).
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') && !startsWith(inputs.python-version, 'graalpy') }}
-        name: Test
-        run: cargo test --no-default-features --features "full $MAYBE_NIGHTLY"
-
-      # Repeat, with multiple-pymethods feature enabled (it's not entirely additive)
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') && !startsWith(inputs.python-version, 'graalpy') }}
-        name: Test
-        run: cargo test --no-default-features --features "multiple-pymethods full $MAYBE_NIGHTLY"
-
-      # Run tests again, but in abi3 mode
-      - if: ${{ !startsWith(inputs.python-version, 'pypy') && !startsWith(inputs.python-version, 'graalpy') }}
-        name: Test (abi3)
-        run: cargo test --no-default-features --features "multiple-pymethods abi3 full $MAYBE_NIGHTLY"
-
-      # Run tests again, for abi3-py37 (the minimal Python version)
-      - if: ${{ (!startsWith(inputs.python-version, 'pypy') && !startsWith(inputs.python-version, 'graalpy')) && (inputs.python-version != '3.7') }}
-        name: Test (abi3-py37)
-        run: cargo test --no-default-features --features "multiple-pymethods abi3-py37 full $MAYBE_NIGHTLY"
-
-      - name: Test proc-macro code
-        run: cargo test --manifest-path=pyo3-macros-backend/Cargo.toml
-
-      - name: Test build config
-        run: cargo test --manifest-path=pyo3-build-config/Cargo.toml
-
-      - name: Test python examples and tests
-        shell: bash
-        run: nox -s test-py
-        env:
-          CARGO_TARGET_DIR: ${{ github.workspace }}/target
-
       - uses: dorny/paths-filter@v3
         if: ${{ inputs.rust == 'stable' && !startsWith(inputs.python-version, 'graalpy') }}
         id: ffi-changes
         with:
-          base: ${{ github.event.pull_request.base.ref || github.event.merge_group.base_ref }}
-          ref: ${{ github.event.pull_request.head.ref || github.event.merge_group.head_ref }}
+          base: ${{ github.event.merge_group.base_ref }}
+          ref: ${{ github.event.merge_group.head_ref }}
           filters: |
             changed:
               - 'pyo3-ffi/**'
@@ -154,9 +107,49 @@ jobs:
         if: ${{ endsWith(inputs.python-version, '-dev') || (steps.ffi-changes.outputs.changed == 'true' && inputs.rust == 'stable' && !startsWith(inputs.python-version, 'graalpy') && !(inputs.python-version == 'pypy3.9' && contains(inputs.os, 'windows'))) }}
         run: nox -s ffi-check
 
+      - if: ${{ github.event_name != 'merge_group' }}
+        name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+
+      - if: ${{ github.event_name != 'merge_group' }}
+        name: Prepare coverage environment
+        run: |
+          cargo llvm-cov clean --workspace --profraw-only
+          nox -s set-coverage-env
+
+      - name: Build docs
+        run: nox -s docs
+
+      - name: Run Rust tests
+        run: nox -s test-rust
+
+      - name: Test python examples and tests
+        shell: bash
+        run: nox -s test-py
+        continue-on-error: ${{ endsWith(inputs.python-version, '-dev') }}
+        env:
+          CARGO_TARGET_DIR: ${{ github.workspace }}/target
+
+      - if: ${{ github.event_name != 'merge_group' }}
+        name: Generate coverage report
+        run: cargo llvm-cov
+          --package=pyo3
+          --package=pyo3-build-config
+          --package=pyo3-macros-backend
+          --package=pyo3-macros
+          --package=pyo3-ffi
+          report --codecov --output-path coverage.json
+
+      - if: ${{ github.event_name != 'merge_group' }}
+        name: Upload coverage report
+        uses: codecov/codecov-action@v5
+        with:
+          files: coverage.json
+          name: ${{ inputs.os }}/${{ inputs.python-version }}/${{ inputs.rust }}
+          token: ${{ secrets.CODECOV_TOKEN }}
+
     env:
-      CARGO_TERM_VERBOSE: true
-      CARGO_BUILD_TARGET: ${{ inputs.rust-target }}
+      CARGO_TERM_VERBOSE: ${{ inputs.verbose }}
       RUST_BACKTRACE: 1
       RUSTFLAGS: "-D warnings"
       RUSTDOCFLAGS: "-D warnings"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 227dcdc3825..428b78e5c9d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -37,6 +37,7 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       MSRV: ${{ steps.resolve-msrv.outputs.MSRV }}
+      verbose: ${{ runner.debug == '1' }}
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
@@ -175,6 +176,7 @@ jobs:
       rust: ${{ matrix.rust }}
       rust-target: ${{ matrix.platform.rust-target }}
       MSRV: ${{ needs.resolve.outputs.MSRV }}
+      verbose: ${{ needs.resolve.outputs.verbose == 'true' }}
     secrets: inherit
     strategy:
       # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present
@@ -225,6 +227,17 @@ jobs:
                 python-architecture: "x64",
                 rust-target: "x86_64-unknown-linux-gnu",
               }
+          # Also test free-threaded Python just for latest Python version, on ubuntu
+          # (run for all OSes on build-full)
+          - rust: stable
+            python-version: "3.13t"
+            platform:
+              {
+                os: "ubuntu-latest",
+                python-architecture: "x64",
+                rust-target: "x86_64-unknown-linux-gnu",
+              }
+
   build-full:
     if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     name: python${{ matrix.python-version }}-${{ matrix.platform.python-architecture }} ${{ matrix.platform.os }} rust-${{ matrix.rust }}
@@ -237,6 +250,7 @@ jobs:
       rust: ${{ matrix.rust }}
       rust-target: ${{ matrix.platform.rust-target }}
       MSRV: ${{ needs.resolve.outputs.MSRV }}
+      verbose: ${{ needs.resolve.outputs.verbose == 'true' }}
     secrets: inherit
     strategy:
       # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present
@@ -252,11 +266,13 @@ jobs:
             "3.11",
             "3.12",
             "3.13",
+            "3.13t",
+            "3.14-dev",
+            "3.14t-dev",
             "pypy3.9",
             "pypy3.10",
             "pypy3.11",
-            "graalpy24.0",
-            "graalpy24.1",
+            "graalpy24.2",
           ]
         platform:
           [
@@ -460,35 +476,6 @@ jobs:
           components: rust-src
       - run: cargo rustdoc --lib --no-default-features --features full,jiff-02 -Zunstable-options --config "build.rustdocflags=[\"--cfg\", \"docsrs\"]"
 
-  coverage:
-    if: ${{ github.event_name != 'merge_group' }}
-    needs: [fmt]
-    name: coverage ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: ["windows-latest", "macos-latest", "ubuntu-latest"]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-python@v5
-        with:
-          python-version: "3.13"
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: llvm-tools-preview,rust-src
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
-      - run: python -m pip install --upgrade pip && pip install nox
-      - run: nox -s coverage
-      - uses: codecov/codecov-action@v5
-        with:
-          files: coverage.json
-          name: ${{ matrix.os }}
-          token: ${{ secrets.CODECOV_TOKEN }}
-
   emscripten:
     name: emscripten
     if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
@@ -545,8 +532,8 @@ jobs:
           components: rust-src
       - name: Install python3 standalone debug build with nox
         run: |
-          PBS_RELEASE="20241016"
-          PBS_PYTHON_VERSION="3.13.0"
+          PBS_RELEASE="20241219"
+          PBS_PYTHON_VERSION="3.13.1"
           PBS_ARCHIVE="cpython-${PBS_PYTHON_VERSION}+${PBS_RELEASE}-x86_64-unknown-linux-gnu-debug-full.tar.zst"
           wget "https://github.com/indygreg/python-build-standalone/releases/download/${PBS_RELEASE}/${PBS_ARCHIVE}"
           tar -I zstd -xf "${PBS_ARCHIVE}"
@@ -575,43 +562,6 @@ jobs:
           echo PYO3_CONFIG_FILE=$PYO3_CONFIG_FILE >> $GITHUB_ENV
       - run: python3 -m nox -s test
 
-  test-free-threaded:
-    needs: [fmt]
-    name: Free threaded tests - ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
-    steps:
-      - uses: actions/checkout@v4
-      - uses: Swatinem/rust-cache@v2
-        with:
-          save-if: ${{ github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'CI-save-pr-cache') }}
-      - uses: dtolnay/rust-toolchain@stable
-        with:
-          components: rust-src
-      - uses: actions/setup-python@v5.5.0
-        with:
-          python-version: "3.13t"
-      - name: Install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
-      - run: python3 -m sysconfig
-      - run: python3 -m pip install --upgrade pip && pip install nox
-      - name: Prepare coverage environment
-        run: |
-          cargo llvm-cov clean --workspace --profraw-only
-          nox -s set-coverage-env
-      - run: nox -s ffi-check
-      - run: nox
-      - name: Generate coverage report
-        run: nox -s generate-coverage-report
-      - name: Upload coverage report
-        uses: codecov/codecov-action@v5
-        with:
-          files: coverage.json
-          name: ${{ matrix.os }}-test-free-threaded
-          token: ${{ secrets.CODECOV_TOKEN }}
-
   test-version-limits:
     needs: [fmt]
     if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
@@ -758,30 +708,32 @@ jobs:
 
   test-introspection:
     needs: [fmt]
+    if: ${{ contains(github.event.pull_request.labels.*.name, 'CI-test-introspection') || contains(github.event.pull_request.labels.*.name, 'CI-build-full') || github.event_name != 'pull_request' }}
     strategy:
       matrix:
-        platform: [
-          {
-            os: "macos-latest",
-            python-architecture: "arm64",
-            rust-target: "aarch64-apple-darwin",
-          },
-          {
-            os: "ubuntu-latest",
-            python-architecture: "x64",
-            rust-target: "x86_64-unknown-linux-gnu",
-          },
-          {
-            os: "windows-latest",
-            python-architecture: "x64",
-            rust-target: "x86_64-pc-windows-msvc",
-          },
-          {
-            os: "windows-latest",
-            python-architecture: "x86",
-            rust-target: "i686-pc-windows-msvc",
-          },
-        ]
+        platform:
+          [
+            {
+              os: "macos-latest",
+              python-architecture: "arm64",
+              rust-target: "aarch64-apple-darwin",
+            },
+            {
+              os: "ubuntu-latest",
+              python-architecture: "x64",
+              rust-target: "x86_64-unknown-linux-gnu",
+            },
+            {
+              os: "windows-latest",
+              python-architecture: "x64",
+              rust-target: "x86_64-pc-windows-msvc",
+            },
+            {
+              os: "windows-latest",
+              python-architecture: "x86",
+              rust-target: "i686-pc-windows-msvc",
+            },
+          ]
     runs-on: ${{ matrix.platform.os }}
     steps:
       - uses: actions/checkout@v4
@@ -811,10 +763,8 @@ jobs:
       - valgrind
       - careful
       - docsrs
-      - coverage
       - emscripten
       - test-debug
-      - test-free-threaded
       - test-version-limits
       - check-feature-powerset
       - test-cross-compilation
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1532d3a7e9f..b13c92caef9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,91 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 
 <!-- towncrier release notes start -->
 
+## [0.25.0] - 2025-05-14
+
+### Packaging
+
+- Support Python 3.14.0b1. [#4811](https://github.com/PyO3/pyo3/pull/4811)
+- Bump supported GraalPy version to 24.2. [#5116](https://github.com/PyO3/pyo3/pull/5116)
+- Add optional `bigdecimal` dependency to add conversions for `bigdecimal::BigDecimal`. [#5011](https://github.com/PyO3/pyo3/pull/5011)
+- Add optional `time` dependency to add conversions for `time` types. [#5057](https://github.com/PyO3/pyo3/pull/5057)
+- Remove `cfg-if` dependency. [#5110](https://github.com/PyO3/pyo3/pull/5110)
+- Add optional `ordered_float` dependency to add conversions for `ordered_float::NotNan` and `ordered_float::OrderedFloat`. [#5114](https://github.com/PyO3/pyo3/pull/5114)
+
+### Added
+
+- Add initial type stub generation to the `experimental-inspect` feature. [#3977](https://github.com/PyO3/pyo3/pull/3977)
+- Add `#[pyclass(generic)]` option to support runtime generic typing. [#4926](https://github.com/PyO3/pyo3/pull/4926)
+- Implement `OnceExt` & `MutexExt` for `parking_lot` & `lock_api`. Use the new extension traits by enabling the `arc_lock`, `lock_api`, or `parking_lot` cargo features. [#5044](https://github.com/PyO3/pyo3/pull/5044)
+- Implement `From`/`Into` for `Borrowed<T>` -> `Py<T>`. [#5054](https://github.com/PyO3/pyo3/pull/5054)
+- Add `PyTzInfo` constructors. [#5055](https://github.com/PyO3/pyo3/pull/5055)
+- Add FFI definition `PY_INVALID_STACK_EFFECT`. [#5064](https://github.com/PyO3/pyo3/pull/5064)
+- Implement `AsRef<Py<PyAny>>` for `Py<T>`, `Bound<T>` and `Borrowed<T>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Add FFI definition `PyModule_Add` and `compat::PyModule_Add`. [#5085](https://github.com/PyO3/pyo3/pull/5085)
+- Add FFI definitions `Py_HashBuffer`, `Py_HashPointer`, and `PyObject_GenericHash`. [#5086](https://github.com/PyO3/pyo3/pull/5086)
+- Support `#[pymodule_export]` on `const` items in declarative modules. [#5096](https://github.com/PyO3/pyo3/pull/5096)
+- Add `#[pyclass(immutable_type)]` option (on Python 3.14+ with `abi3`, or 3.10+ otherwise) for immutable type objects. [#5101](https://github.com/PyO3/pyo3/pull/5101)
+- Support `#[pyo3(rename_all)]` support on `#[derive(IntoPyObject)]`. [#5112](https://github.com/PyO3/pyo3/pull/5112)
+- Add `PyRange` wrapper. [#5117](https://github.com/PyO3/pyo3/pull/5117)
+
+### Changed
+
+- Enable use of `datetime` types with `abi3` feature enabled. [#4970](https://github.com/PyO3/pyo3/pull/4970)
+- Deprecate `timezone_utc` in favor of `PyTzInfo::utc`. [#5055](https://github.com/PyO3/pyo3/pull/5055)
+- Reduce visibility of some CPython implementation details: [#5064](https://github.com/PyO3/pyo3/pull/5064)
+  - The FFI definition `PyCodeObject` is now an opaque struct on all Python versions.
+  - The FFI definition `PyFutureFeatures` is now only defined up until Python 3.10 (it was present in CPython headers but unused in 3.11 and 3.12).
+- Change `PyAnyMethods::is` to take `other: &Bound<T>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Change `Py::is` to take `other: &Py<T>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Change `PyVisit::call` to take `T: Into<Option<&Py<T>>>`. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Expose `PyDateTime_DATE_GET_TZINFO` and `PyDateTime_TIME_GET_TZINFO` on PyPy 3.10 and later. [#5079](https://github.com/PyO3/pyo3/pull/5079)
+- Add `#[track_caller]` to `with_gil` and `with_gil_unchecked`. [#5109](https://github.com/PyO3/pyo3/pull/5109)
+- Use `std::thread::park()` instead of `libc::pause()` or `sleep(9999999)`. [#5115](https://github.com/PyO3/pyo3/pull/5115)
+
+### Removed
+
+- Remove all functionality deprecated in PyO3 0.23. [#4982](https://github.com/PyO3/pyo3/pull/4982)
+- Remove deprecated `IntoPy` and `ToPyObject` traits. [#5010](https://github.com/PyO3/pyo3/pull/5010)
+- Remove private types from `pyo3-ffi` (i.e. starting with `_Py`) which are not referenced by public APIs: `_PyLocalMonitors`, `_Py_GlobalMonitors`, `_PyCoCached`, `_PyCoLineInstrumentationData`, `_PyCoMonitoringData`, `_PyCompilerSrcLocation`, `_PyErr_StackItem`. [#5064](https://github.com/PyO3/pyo3/pull/5064)
+- Remove FFI definition `PyCode_GetNumFree` (PyO3 cannot support it due to knowledge of the code object). [#5064](https://github.com/PyO3/pyo3/pull/5064)
+- Remove `AsPyPointer` trait. [#5071](https://github.com/PyO3/pyo3/pull/5071)
+- Remove support for the deprecated string form of `from_py_with`. [#5097](https://github.com/PyO3/pyo3/pull/5097)
+- Remove FFI definitions of private static variables: `_PyMethodWrapper_Type`, `_PyCoroWrapper_Type`, `_PyImport_FrozenBootstrap`, `_PyImport_FrozenStdlib`, `_PyImport_FrozenTest`, `_PyManagedBuffer_Type`, `_PySet_Dummy`, `_PyWeakref_ProxyType`, and `_PyWeakref_CallableProxyType`. [#5105](https://github.com/PyO3/pyo3/pull/5105)
+- Remove FFI definitions `PyASCIIObjectState`, `PyUnicode_IS_ASCII`, `PyUnicode_IS_COMPACT`, and `PyUnicode_IS_COMPACT_ASCII` on Python 3.14 and newer. [#5133](https://github.com/PyO3/pyo3/pull/5133)
+
+### Fixed
+
+- Correctly pick up the shared state for conda-based Python installation when reading information from sysconfigdata. [#5037](https://github.com/PyO3/pyo3/pull/5037)
+- Fix compile failure with `#[derive(IntoPyObject, FromPyObject)]` when using `#[pyo3()]` options recognised by only one of the two derives. [#5070](https://github.com/PyO3/pyo3/pull/5070)
+- Fix various compile errors from missing FFI definitions using certain feature combinations on PyPy and GraalPy. [#5091](https://github.com/PyO3/pyo3/pull/5091)
+- Fallback on `backports.zoneinfo` for python <3.9 when converting timezones into python. [#5120](https://github.com/PyO3/pyo3/pull/5120)
+
+## [0.24.2] - 2025-04-21
+
+### Fixed
+
+- Fix `unused_imports` lint of `#[pyfunction]` and `#[pymethods]` expanded in `macro_rules` context. [#5030](https://github.com/PyO3/pyo3/pull/5030)
+- Fix size of `PyCodeObject::_co_instrumentation_version` ffi struct member on Python 3.13 for systems where `uintptr_t` is not 64 bits. [#5048](https://github.com/PyO3/pyo3/pull/5048)
+- Fix struct-type complex enum variant fields incorrectly exposing raw identifiers as `r#ident` in Python bindings. [#5050](https://github.com/PyO3/pyo3/pull/5050)
+
+## [0.24.1] - 2025-03-31
+
+### Added
+
+- Add `abi3-py313` feature. [#4969](https://github.com/PyO3/pyo3/pull/4969)
+- Add `PyAnyMethods::getattr_opt`. [#4978](https://github.com/PyO3/pyo3/pull/4978)
+- Add `PyInt::new` constructor for all supported number types (i32, u32, i64, u64, isize, usize). [#4984](https://github.com/PyO3/pyo3/pull/4984)
+- Add `pyo3::sync::with_critical_section2`. [#4992](https://github.com/PyO3/pyo3/pull/4992)
+- Implement `PyCallArgs` for `Borrowed<'_, 'py, PyTuple>`, `&Bound<'py, PyTuple>`, and `&Py<PyTuple>`. [#5013](https://github.com/PyO3/pyo3/pull/5013)
+
+### Fixed
+
+- Fix `is_type_of` for native types not using same specialized check as `is_type_of_bound`. [#4981](https://github.com/PyO3/pyo3/pull/4981)
+- Fix `Probe` class naming issue with `#[pymethods]`. [#4988](https://github.com/PyO3/pyo3/pull/4988)
+- Fix compile failure with required `#[pyfunction]` arguments taking `Option<&str>` and `Option<&T>` (for `#[pyclass]` types). [#5002](https://github.com/PyO3/pyo3/pull/5002)
+- Fix `PyString::from_object` causing of bounds reads whith `encoding` and `errors` parameters which are not nul-terminated. [#5008](https://github.com/PyO3/pyo3/pull/5008)
+- Fix compile error when additional options follow after `crate` for `#[pyfunction]`. [#5015](https://github.com/PyO3/pyo3/pull/5015)
+
 ## [0.24.0] - 2025-03-09
 
 ### Packaging
@@ -17,6 +102,7 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 - Add supported CPython/PyPy versions to cargo package metadata. [#4756](https://github.com/PyO3/pyo3/pull/4756)
 - Bump `target-lexicon` dependency to 0.13. [#4822](https://github.com/PyO3/pyo3/pull/4822)
 - Add optional `jiff` dependency to add conversions for `jiff` datetime types. [#4823](https://github.com/PyO3/pyo3/pull/4823)
+- Add optional `uuid` dependency to add conversions for `uuid::Uuid`. [#4864](https://github.com/PyO3/pyo3/pull/4864)
 - Bump minimum supported `inventory` version to 0.3.5. [#4954](https://github.com/PyO3/pyo3/pull/4954)
 
 ### Added
@@ -25,7 +111,6 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 - Add `PyCallArgs` trait for passing arguments into the Python calling protocol. This enabled using a faster calling convention for certain types, improving performance. [#4768](https://github.com/PyO3/pyo3/pull/4768)
 - Add `#[pyo3(default = ...']` option for `#[derive(FromPyObject)]` to set a default value for extracted fields of named structs. [#4829](https://github.com/PyO3/pyo3/pull/4829)
 - Add `#[pyo3(into_py_with = ...)]` option for `#[derive(IntoPyObject, IntoPyObjectRef)]`. [#4850](https://github.com/PyO3/pyo3/pull/4850)
-- Add uuid to/from python conversions. [#4864](https://github.com/PyO3/pyo3/pull/4864)
 - Add FFI definitions `PyThreadState_GetFrame` and `PyFrame_GetBack`. [#4866](https://github.com/PyO3/pyo3/pull/4866)
 - Optimize `last` for `BoundListIterator`, `BoundTupleIterator` and `BorrowedTupleIterator`. [#4878](https://github.com/PyO3/pyo3/pull/4878)
 - Optimize `Iterator::count()` for `PyDict`, `PyList`, `PyTuple` & `PySet`. [#4878](https://github.com/PyO3/pyo3/pull/4878)
@@ -60,6 +145,7 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 
 
 ## [0.23.5] - 2025-02-22
+
 ### Packaging
 
 - Add support for PyPy3.11 [#4760](https://github.com/PyO3/pyo3/pull/4760)
@@ -109,7 +195,6 @@ To see unreleased changes, please see the [CHANGELOG on the main branch guide](h
 - Fix unresolved symbol link failures on Windows when compiling for Python 3.13t using the `generate-import-lib` feature. [#4749](https://github.com/PyO3/pyo3/pull/4749)
 - Fix compile-time regression in PyO3 0.23.0 where changing `PYO3_CONFIG_FILE` would not reconfigure PyO3 for the new interpreter. [#4758](https://github.com/PyO3/pyo3/pull/4758)
 
-
 ## [0.23.2] - 2024-11-25
 
 ### Added
@@ -2113,7 +2198,10 @@ Yanked
 
 - Initial release
 
-[Unreleased]: https://github.com/pyo3/pyo3/compare/v0.24.0...HEAD
+[Unreleased]: https://github.com/pyo3/pyo3/compare/v0.25.0...HEAD
+[0.25.0]: https://github.com/pyo3/pyo3/compare/v0.24.2...v0.25.0
+[0.24.2]: https://github.com/pyo3/pyo3/compare/v0.24.1...v0.24.2
+[0.24.1]: https://github.com/pyo3/pyo3/compare/v0.24.0...v0.24.1
 [0.24.0]: https://github.com/pyo3/pyo3/compare/v0.23.5...v0.24.0
 [0.23.5]: https://github.com/pyo3/pyo3/compare/v0.23.4...v0.23.5
 [0.23.4]: https://github.com/pyo3/pyo3/compare/v0.23.3...v0.23.4
diff --git a/Cargo.toml b/Cargo.toml
index f0047d1a162..55e4a29170c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3"
-version = "0.25.0-dev"
+version = "0.25.0"
 description = "Bindings to Python interpreter"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 readme = "README.md"
@@ -15,16 +15,15 @@ edition = "2021"
 rust-version = "1.63"
 
 [dependencies]
-cfg-if = "1.0"
 libc = "0.2.62"
 memoffset = "0.9"
 once_cell = "1.13"
 
 # ffi bindings to the python interpreter, split into a separate crate so they can be used independently
-pyo3-ffi = { path = "pyo3-ffi", version = "=0.25.0-dev" }
+pyo3-ffi = { path = "pyo3-ffi", version = "=0.25.0" }
 
 # support crates for macros feature
-pyo3-macros = { path = "pyo3-macros", version = "=0.25.0-dev", optional = true }
+pyo3-macros = { path = "pyo3-macros", version = "=0.25.0", optional = true }
 indoc = { version = "2.0.1", optional = true }
 unindent = { version = "0.2.1", optional = true }
 
@@ -44,10 +43,14 @@ jiff-02 = { package = "jiff", version = "0.2", optional = true }
 num-bigint = { version = "0.4.2", optional = true }
 num-complex = { version = ">= 0.4.6, < 0.5", optional = true }
 num-rational = { version = "0.4.1", optional = true }
+ordered-float = { version = "5.0.0", default-features = false, optional = true }
 rust_decimal = { version = "1.15", default-features = false, optional = true }
+time = { version = "0.3.38", default-features = false, optional = true }
 serde = { version = "1.0", optional = true }
 smallvec = { version = "1.0", optional = true }
 uuid = { version = "1.11.0", optional = true  }
+lock_api = { version = "0.4", optional = true }
+parking_lot = { version = "0.12", optional = true}
 
 [target.'cfg(not(target_has_atomic = "64"))'.dependencies]
 portable-atomic = "1.0"
@@ -67,9 +70,10 @@ futures = "0.3.28"
 tempfile = "3.12.0"
 static_assertions = "1.1.0"
 uuid = { version = "1.10.0", features = ["v4"] }
+parking_lot = { version = "0.12.3", features = ["arc_lock"]}
 
 [build-dependencies]
-pyo3-build-config = { path = "pyo3-build-config", version = "=0.25.0-dev", features = ["resolve-config"] }
+pyo3-build-config = { path = "pyo3-build-config", version = "=0.25.0", features = ["resolve-config"] }
 
 [features]
 default = ["macros"]
@@ -102,7 +106,8 @@ abi3-py39 = ["abi3-py310", "pyo3-build-config/abi3-py39", "pyo3-ffi/abi3-py39"]
 abi3-py310 = ["abi3-py311", "pyo3-build-config/abi3-py310", "pyo3-ffi/abi3-py310"]
 abi3-py311 = ["abi3-py312", "pyo3-build-config/abi3-py311", "pyo3-ffi/abi3-py311"]
 abi3-py312 = ["abi3-py313", "pyo3-build-config/abi3-py312", "pyo3-ffi/abi3-py312"]
-abi3-py313 = ["abi3", "pyo3-build-config/abi3-py313", "pyo3-ffi/abi3-py313"]
+abi3-py313 = ["abi3-py314", "pyo3-build-config/abi3-py313", "pyo3-ffi/abi3-py313"]
+abi3-py314 = ["abi3", "pyo3-build-config/abi3-py314", "pyo3-ffi/abi3-py314"]
 
 # Automatically generates `python3.dll` import libraries for Windows targets.
 generate-import-lib = ["pyo3-ffi/generate-import-lib"]
@@ -113,6 +118,9 @@ auto-initialize = []
 # Enables `Clone`ing references to Python objects `Py<T>` which panics if the GIL is not held.
 py-clone = []
 
+parking_lot = ["dep:parking_lot", "lock_api"]
+arc_lock = ["lock_api", "lock_api/arc_lock", "parking_lot?/arc_lock"]
+
 # Optimizes PyObject to Vec conversion and so on.
 nightly = []
 
@@ -122,6 +130,7 @@ full = [
     "macros",
     # "multiple-pymethods", # Not supported by wasm
     "anyhow",
+    "arc_lock",
     "bigdecimal",
     "chrono",
     "chrono-tz",
@@ -131,9 +140,12 @@ full = [
     "eyre",
     "hashbrown",
     "indexmap",
+    "lock_api",
     "num-bigint",
     "num-complex",
     "num-rational",
+    "ordered-float",
+    "parking_lot",
     "py-clone",
     "rust_decimal",
     "serde",
diff --git a/Contributing.md b/Contributing.md
index 054ef42fb88..40fcb1af030 100644
--- a/Contributing.md
+++ b/Contributing.md
@@ -179,6 +179,20 @@ Below are guidelines on what compatibility all PRs are expected to deliver for e
 
 PyO3 supports all officially supported Python versions, as well as the latest PyPy3 release. All of these versions are tested in CI.
 
+#### Adding support for new CPython versions
+
+If you plan to add support for a pre-release version of CPython, here's a (non-exhaustive) checklist:
+
+ - [ ] Wait until the last alpha release (usually alpha7), since ABI is not guranteed until the first beta release
+ - [ ] Add prelease_ver-dev (e.g. `3.14-dev`) to `‎.github/workflows/ci.yml`, and bump version in `noxfile.py`, `pyo3-ffi/Cargo.toml` under `max-version` within  `[package.metadata.cpython]`, and `max` within `pyo3-ffi/build.rs`
+- [ ] Add a new abi3-prerelease feature for the version (e.g. `abi3-py314`)
+   - In `pyo3-build-config/Cargo.toml`, set abi3-most_current_stable to ["abi3-prerelease"] and abi3-prerelease to ["abi3"]
+   - In `pyo3-ffi/Cargo.toml`, set abi3-most_current_stable to ["abi3-prerelease", "pyo3-build-config/abi3-most_current_stable"] and abi3-prerelease to ["abi3", "pyo3-build-config/abi3-prerelease"]
+   - In `Cargo.toml`, set abi3-most_current_stable to ["abi3-prerelease", "pyo3-ffi/abi3-most_current_stable"] and abi3-prerelease to ["abi3", "pyo3-ffi/abi3-prerelease"]
+ - [ ] Use `#[cfg(Py_prerelease])` (e.g. `#[cfg(Py_3_14)]`) and `#[cfg(not(Py_prerelease]))` to indicate changes between the stable branches of CPython and the pre-release
+ - [ ] Do not add a Rust binding to any function, struct, or global variable prefixed with `_` in CPython's headers
+ - [ ] Ping @ngoldbaum and @davidhewitt for assistance
+
 ### Rust
 
 PyO3 aims to make use of up-to-date Rust language features to keep the implementation as efficient as possible.
diff --git a/README.md b/README.md
index 17a20382b74..47a74ec84a3 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,7 @@ Requires Rust 1.63 or greater.
 PyO3 supports the following Python distributions:
   - CPython 3.7 or greater
   - PyPy 7.3 (Python 3.9+)
-  - GraalPy 24.0 or greater (Python 3.10+)
+  - GraalPy 24.2 or greater (Python 3.11+)
 
 You can use PyO3 to write a native Python module in Rust, or to embed Python in a Rust binary. The following sections explain each of these in turn.
 
@@ -71,7 +71,7 @@ name = "string_sum"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.24.0", features = ["extension-module"] }
+pyo3 = { version = "0.25.0", features = ["extension-module"] }
 ```
 
 **`src/lib.rs`**
@@ -140,7 +140,7 @@ Start a new project with `cargo new` and add  `pyo3` to the `Cargo.toml` like th
 
 ```toml
 [dependencies.pyo3]
-version = "0.24.0"
+version = "0.25.0"
 features = ["auto-initialize"]
 ```
 
diff --git a/Releasing.md b/Releasing.md
index 545783c598c..d3a1b4cf8c4 100644
--- a/Releasing.md
+++ b/Releasing.md
@@ -44,9 +44,10 @@ Wait a couple of days in case anyone wants to hold up the release to add bugfixe
 ## 4. Put live
 
 To put live:
-- 1. run `nox -s publish` to put live on crates.io
-- 2. publish the release on Github
-- 3. merge the release PR
+- 1. merge the release PR
+- 2. publish a release on GitHub targeting the release branch
+
+CI will automatically push to `crates.io`.
 
 ## 5. Tidy the main branch
 
diff --git a/build.rs b/build.rs
index 68a658bf285..fd28b03b79d 100644
--- a/build.rs
+++ b/build.rs
@@ -38,7 +38,7 @@ fn configure_pyo3() -> Result<()> {
     ensure_auto_initialize_ok(interpreter_config)?;
 
     for cfg in interpreter_config.build_script_outputs() {
-        println!("{}", cfg)
+        println!("{cfg}")
     }
 
     // Emit cfgs like `invalid_from_utf8_lint`
diff --git a/examples/decorator/.template/pre-script.rhai b/examples/decorator/.template/pre-script.rhai
index 1ad80e9afbe..80ebe3ce006 100644
--- a/examples/decorator/.template/pre-script.rhai
+++ b/examples/decorator/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.24.0");
+variable::set("PYO3_VERSION", "0.25.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/pyproject.toml", "pyproject.toml");
 file::delete(".template");
diff --git a/examples/decorator/src/lib.rs b/examples/decorator/src/lib.rs
index 4c5471c9945..69915ff8256 100644
--- a/examples/decorator/src/lib.rs
+++ b/examples/decorator/src/lib.rs
@@ -46,7 +46,7 @@ impl PyCounter {
         let new_count = self.count.fetch_add(1, Ordering::Relaxed);
         let name = self.wraps.getattr(py, "__name__")?;
 
-        println!("{} has been called {} time(s).", name, new_count);
+        println!("{name} has been called {new_count} time(s).");
 
         // After doing something, we finally forward the call to the wrapped function
         let ret = self.wraps.call(py, args, kwargs)?;
diff --git a/examples/maturin-starter/.template/pre-script.rhai b/examples/maturin-starter/.template/pre-script.rhai
index 1ad80e9afbe..80ebe3ce006 100644
--- a/examples/maturin-starter/.template/pre-script.rhai
+++ b/examples/maturin-starter/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.24.0");
+variable::set("PYO3_VERSION", "0.25.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/pyproject.toml", "pyproject.toml");
 file::delete(".template");
diff --git a/examples/plugin/.template/pre-script.rhai b/examples/plugin/.template/pre-script.rhai
index ffd73d3a0fa..2a21f6b2e53 100644
--- a/examples/plugin/.template/pre-script.rhai
+++ b/examples/plugin/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.24.0");
+variable::set("PYO3_VERSION", "0.25.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/plugin_api/Cargo.toml", "plugin_api/Cargo.toml");
 file::delete(".template");
diff --git a/examples/setuptools-rust-starter/.template/pre-script.rhai b/examples/setuptools-rust-starter/.template/pre-script.rhai
index fd6e6775627..92eeabb3ea8 100644
--- a/examples/setuptools-rust-starter/.template/pre-script.rhai
+++ b/examples/setuptools-rust-starter/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.24.0");
+variable::set("PYO3_VERSION", "0.25.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/setup.cfg", "setup.cfg");
 file::delete(".template");
diff --git a/examples/setuptools-rust-starter/noxfile.py b/examples/setuptools-rust-starter/noxfile.py
index 222be921062..d3579912ea7 100644
--- a/examples/setuptools-rust-starter/noxfile.py
+++ b/examples/setuptools-rust-starter/noxfile.py
@@ -1,8 +1,11 @@
 import nox
+import sys
 
 
 @nox.session
 def python(session: nox.Session):
+    if sys.version_info < (3, 9):
+        session.skip("Python 3.9 or later is required for setuptools-rust 1.11")
     session.env["SETUPTOOLS_RUST_CARGO_PROFILE"] = "dev"
     session.install(".[dev]")
     session.run("pytest")
diff --git a/examples/word-count/.template/pre-script.rhai b/examples/word-count/.template/pre-script.rhai
index 1ad80e9afbe..80ebe3ce006 100644
--- a/examples/word-count/.template/pre-script.rhai
+++ b/examples/word-count/.template/pre-script.rhai
@@ -1,4 +1,4 @@
-variable::set("PYO3_VERSION", "0.24.0");
+variable::set("PYO3_VERSION", "0.25.0");
 file::rename(".template/Cargo.toml", "Cargo.toml");
 file::rename(".template/pyproject.toml", "pyproject.toml");
 file::delete(".template");
diff --git a/guide/pyclass-parameters.md b/guide/pyclass-parameters.md
index 7ebca2ec821..27b15118dd4 100644
--- a/guide/pyclass-parameters.md
+++ b/guide/pyclass-parameters.md
@@ -10,8 +10,10 @@
 | <span style="white-space: pre">`extends = BaseType`</span>  | Use a custom baseclass. Defaults to [`PyAny`][params-1] |
 | <span style="white-space: pre">`freelist = N`</span> |  Implements a [free list][params-2] of size N. This can improve performance for types that are often created and deleted in quick succession. Profile your code to see whether `freelist` is right for you.  |
 | <span style="white-space: pre">`frozen`</span> | Declares that your pyclass is immutable. It removes the borrow checker overhead when retrieving a shared reference to the Rust struct, but disables the ability to get a mutable reference. |
+| `generic` | Implements runtime parametrization for the class following [PEP 560](https://peps.python.org/pep-0560/). |
 | `get_all` | Generates getters for all fields of the pyclass. |
 | `hash` | Implements `__hash__` using the `Hash` implementation of the underlying Rust datatype. |
+| `immutable_type` | Makes the type object immutable. Supported on 3.14+ with the `abi3` feature active, or 3.10+ otherwise. |
 | `mapping` |  Inform PyO3 that this class is a [`Mapping`][params-mapping], and so leave its implementation of sequence C-API slots empty. |
 | <span style="white-space: pre">`module = "module_name"`</span> |  Python code will see the class as being defined in this module. Defaults to `builtins`. |
 | <span style="white-space: pre">`name = "python_name"`</span> | Sets the name that Python sees this class as. Defaults to the name of the Rust struct. |
diff --git a/guide/src/async-await.md b/guide/src/async-await.md
index f9fc33fe3c5..1e0772b8a09 100644
--- a/guide/src/async-await.md
+++ b/guide/src/async-await.md
@@ -66,8 +66,8 @@ where
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let waker = cx.waker();
-        Python::with_gil(|gil| {
-            gil.allow_threads(|| pin!(&mut self.0).poll(&mut Context::from_waker(waker)))
+        Python::with_gil(|py| {
+            py.allow_threads(|| pin!(&mut self.0).poll(&mut Context::from_waker(waker)))
         })
     }
 }
diff --git a/guide/src/class/object.md b/guide/src/class/object.md
index 3b9f1aafa40..a3a136fe015 100644
--- a/guide/src/class/object.md
+++ b/guide/src/class/object.md
@@ -77,8 +77,8 @@ To automatically generate the `__str__` implementation using a `Display` trait i
 # use pyo3::prelude::*;
 #
 # #[allow(dead_code)]
-# #[pyclass(str)]
-# struct Coordinate {
+#[pyclass(str)]
+struct Coordinate {
     x: i32,
     y: i32,
     z: i32,
@@ -104,8 +104,8 @@ For convenience, a shorthand format string can be passed to `str` as `str="<form
 # use pyo3::prelude::*;
 #
 # #[allow(dead_code)]
-# #[pyclass(str="({x}, {y}, {z})")]
-# struct Coordinate {
+#[pyclass(str="({x}, {y}, {z})")]
+struct Coordinate {
     x: i32,
     y: i32,
     z: i32,
diff --git a/guide/src/class/protocols.md b/guide/src/class/protocols.md
index 3dee8db137d..44aa9199e36 100644
--- a/guide/src/class/protocols.md
+++ b/guide/src/class/protocols.md
@@ -443,9 +443,7 @@ struct ClassWithGCSupport {
 #[pymethods]
 impl ClassWithGCSupport {
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
-        if let Some(obj) = &self.obj {
-            visit.call(obj)?
-        }
+        visit.call(&self.obj)?;
         Ok(())
     }
 
diff --git a/guide/src/class/thread-safety.md b/guide/src/class/thread-safety.md
index 75c0b1a7423..d0cf9e10a7f 100644
--- a/guide/src/class/thread-safety.md
+++ b/guide/src/class/thread-safety.md
@@ -101,7 +101,7 @@ impl MyClass {
 }
 ```
 
-If you need to lock around state stored in the Python interpreter or otherwise call into the Python C API while a lock is held, you might find the `MutexExt` trait useful. It provides a `lock_py_attached` method for `std::sync::Mutex` that avoids deadlocks with the GIL or other global synchronization events in the interpreter.
+If you need to lock around state stored in the Python interpreter or otherwise call into the Python C API while a lock is held, you might find the `MutexExt` trait useful. It provides a `lock_py_attached` method for `std::sync::Mutex` that avoids deadlocks with the GIL or other global synchronization events in the interpreter. Additionally, support for the `parking_lot` and `lock_api` synchronization libraries is gated behind the `parking_lot` and `lock_api` features. You can also enable the `arc_lock` feature if you need the `arc_lock` features of either library.
 
 ### Wrapping unsynchronized data
 
diff --git a/guide/src/conversions/tables.md b/guide/src/conversions/tables.md
index 34299d830d1..23d6942b177 100644
--- a/guide/src/conversions/tables.md
+++ b/guide/src/conversions/tables.md
@@ -17,7 +17,7 @@ The table below contains the Python type and the corresponding function argument
 | `bytes`       | `Vec<u8>`, `&[u8]`, `Cow<[u8]>` | `PyBytes`           |
 | `bool`        | `bool`                          | `PyBool`            |
 | `int`         | `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`, `num_bigint::BigInt`[^1], `num_bigint::BigUint`[^1] | `PyInt` |
-| `float`       | `f32`, `f64`                    | `PyFloat`           |
+| `float`       | `f32`, `f64`, `ordered_float::NotNan`[^10], `ordered_float::OrderedFloat`[^10]                    | `PyFloat`           |
 | `complex`     | `num_complex::Complex`[^2]      | `PyComplex`         |
 | `fractions.Fraction`| `num_rational::Ratio`[^8] | -         |
 | `list[T]`     | `Vec<T>`                        | `PyList`            |
@@ -37,8 +37,8 @@ The table below contains the Python type and the corresponding function argument
 | `datetime.timedelta` | `Duration`, `chrono::Duration`[^5] | `PyDelta`           |
 | `decimal.Decimal` | `rust_decimal::Decimal`[^7] | -                    |
 | `decimal.Decimal` | `bigdecimal::BigDecimal`[^9] | -                   |
-| `ipaddress.IPv4Address` | `std::net::IpAddr`, `std::net::IpV4Addr` | - |
-| `ipaddress.IPv6Address` | `std::net::IpAddr`, `std::net::IpV6Addr` | - |
+| `ipaddress.IPv4Address` | `std::net::IpAddr`, `std::net::Ipv4Addr` | - |
+| `ipaddress.IPv6Address` | `std::net::IpAddr`, `std::net::Ipv6Addr` | - |
 | `os.PathLike ` | `PathBuf`, `Path`              | `PyString` |
 | `pathlib.Path` | `PathBuf`, `Path`              | `PyString` |
 | `typing.Optional[T]` | `Option<T>`              | -                    |
@@ -119,3 +119,5 @@ Finally, the following Rust types are also able to convert to Python as return v
 [^8]: Requires the `num-rational` optional feature.
 
 [^9]: Requires the `bigdecimal` optional feature.
+
+[^10]: Requires the `ordered-float` optional feature.
diff --git a/guide/src/features.md b/guide/src/features.md
index 4ecd14e23fa..450c1b4ea04 100644
--- a/guide/src/features.md
+++ b/guide/src/features.md
@@ -121,6 +121,10 @@ These features enable conversions between Python types and types from other Rust
 
 Adds a dependency on [anyhow](https://docs.rs/anyhow). Enables a conversion from [anyhow](https://docs.rs/anyhow)’s [`Error`](https://docs.rs/anyhow/latest/anyhow/struct.Error.html) type to [`PyErr`]({{#PYO3_DOCS_URL}}/pyo3/struct.PyErr.html), for easy error handling.
 
+### `arc_lock`
+
+Enables Pyo3's `MutexExt` trait for all Mutexes that extend on [`lock_api::Mutex`](https://docs.rs/lock_api/latest/lock_api/struct.Mutex.html) and are wrapped in an [`Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html) type. Like [`Arc<parking_lot::Mutex>`](https://docs.rs/parking_lot/latest/parking_lot/type.Mutex.html#method.lock_arc)
+
 ### `bigdecimal`
 Adds a dependency on [bigdecimal](https://docs.rs/bigdecimal) and enables conversions into its [`BigDecimal`](https://docs.rs/bigdecimal/latest/bigdecimal/struct.BigDecimal.html) type.
 
@@ -168,6 +172,10 @@ Adds a dependency on [jiff@0.2](https://docs.rs/jiff/0.2) and requires MSRV 1.70
 - [Zoned](https://docs.rs/jiff/0.2/jiff/struct.Zoned.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
 - [Timestamp](https://docs.rs/jiff/0.2/jiff/struct.Timestamp.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
 
+### `lock_api`
+
+Adds a dependency on [lock_api](https://docs.rs/lock_api) and enables Pyo3's `MutexExt` trait for all mutexes that extend on [`lock_api::Mutex`](https://docs.rs/lock_api/latest/lock_api/struct.Mutex.html) (like `parking_lot` or `spin`).
+
 ### `num-bigint`
 
 Adds a dependency on [num-bigint](https://docs.rs/num-bigint) and enables conversions into its [`BigInt`](https://docs.rs/num-bigint/latest/num_bigint/struct.BigInt.html) and [`BigUint`](https://docs.rs/num-bigint/latest/num_bigint/struct.BigUint.html) types.
@@ -180,10 +188,31 @@ Adds a dependency on [num-complex](https://docs.rs/num-complex) and enables conv
 
 Adds a dependency on [num-rational](https://docs.rs/num-rational) and enables conversions into its [`Ratio`](https://docs.rs/num-rational/latest/num_rational/struct.Ratio.html) type.
 
+### `ordered-float`
+
+Adds a dependency on [ordered-float](https://docs.rs/ordered-float) and enables conversions between [ordered-float](https://docs.rs/ordered-float)'s types and Python:
+- [NotNan](https://docs.rs/ordered-float/latest/ordered_float/struct.NotNan.html) -> [`PyFloat`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyFloat.html)
+- [OrderedFloat](https://docs.rs/ordered-float/latest/ordered_float/struct.OrderedFloat.html) -> [`PyFloat`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyFloat.html)
+
+### `parking-lot`
+
+Adds a dependency on [parking_lot](https://docs.rs/parking_lot) and enables Pyo3's `OnceExt` & `MutexExt` traits for [`parking_lot::Once`](https://docs.rs/parking_lot/latest/parking_lot/struct.Once.html) and [`parking_lot::Mutex`](https://docs.rs/parking_lot/latest/parking_lot/type.Mutex.html) types.
+
 ### `rust_decimal`
 
 Adds a dependency on [rust_decimal](https://docs.rs/rust_decimal) and enables conversions into its [`Decimal`](https://docs.rs/rust_decimal/latest/rust_decimal/struct.Decimal.html) type.
 
+### `time`
+
+Adds a dependency on [time](https://docs.rs/time) and requires MSRV 1.67.1. Enables conversions between [time](https://docs.rs/time)'s types and Python:
+- [Date](https://docs.rs/time/0.3.38/time/struct.Date.html) -> [`PyDate`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDate.html)
+- [Time](https://docs.rs/time/0.3.38/time/struct.Time.html) -> [`PyTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTime.html)
+- [OffsetDateTime](https://docs.rs/time/0.3.38/time/struct.OffsetDateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [PrimitiveDateTime](https://docs.rs/time/0.3.38/time/struct.PrimitiveDateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+- [Duration](https://docs.rs/time/0.3.38/time/struct.Duration.html) -> [`PyDelta`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDelta.html)
+- [UtcOffset](https://docs.rs/time/0.3.38/time/struct.UtcOffset.html) -> [`PyTzInfo`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyTzInfo.html)
+- [UtcDateTime](https://docs.rs/time/0.3.38/time/struct.UtcDateTime.html) -> [`PyDateTime`]({{#PYO3_DOCS_URL}}/pyo3/types/struct.PyDateTime.html)
+
 ### `serde`
 
 Enables (de)serialization of `Py<T>` objects via [serde](https://serde.rs/).
diff --git a/guide/src/migration.md b/guide/src/migration.md
index 13ca506662c..3beaa5bc07c 100644
--- a/guide/src/migration.md
+++ b/guide/src/migration.md
@@ -3,9 +3,26 @@
 This guide can help you upgrade code through breaking changes from one PyO3 version to the next.
 For a detailed list of all changes, see the [CHANGELOG](changelog.md).
 
-## from 0.22.* to 0.23
+## from 0.24.* to 0.25
+### `AsPyPointer` removal
 <details open>
 <summary><small>Click to expand</small></summary>
+The `AsPyPointer` trait is mostly a leftover from the now removed gil-refs API. The last remaining uses were the GC API, namely `PyVisit::call`, and identity comparison (`PyAnyMethods::is` and `Py::is`).
+
+`PyVisit::call` has been updated to take `T: Into<Option<&Py<T>>>`, which allows for arguments of type `&Py<T>`, `&Option<Py<T>>` and `Option<&Py<T>>`. It is unlikely any changes are needed here to migrate.
+
+`PyAnyMethods::is`/`Py::is` has been updated to take `T: AsRef<Py<PyAny>>>`. Additionally `AsRef<Py<PyAny>>>` implementations were added for `Py`, `Bound` and `Borrowed`. Because of the existing `AsRef<Bound<PyAny>> for Bound<T>` implementation this may cause inference issues in non-generic code. This can be easily migrated by switching to `as_any` instead of `as_ref` for these calls.
+</details>
+
+## from 0.23.* to 0.24
+<details>
+<summary><small>Click to expand</small></summary>
+There were no significant changes from 0.23 to 0.24 which required documenting in this guide.
+</details>
+
+## from 0.22.* to 0.23
+<details>
+<summary><small>Click to expand</small></summary>
 
 PyO3 0.23 is a significant rework of PyO3's internals for two major improvements:
  - Support of Python 3.13's new freethreaded build (aka "3.13t")
@@ -20,7 +37,7 @@ The sections below discuss the rationale and details of each change in more dept
 </details>
 
 ### Free-threaded Python Support
-<details open>
+<details>
 <summary><small>Click to expand</small></summary>
 
 PyO3 0.23 introduces initial support for the new free-threaded build of
@@ -43,7 +60,7 @@ See [the guide section on free-threaded Python](free-threading.md) for more deta
 </details>
 
 ### New `IntoPyObject` trait unifies to-Python conversions
-<details open>
+<details>
 <summary><small>Click to expand</small></summary>
 
 PyO3 0.23 introduces a new `IntoPyObject` trait to convert Rust types into Python objects which replaces both `IntoPy` and `ToPyObject`.
@@ -132,7 +149,7 @@ impl<'a, 'py> IntoPyObject<'py> for &'a MyPyObjectWrapper {
 </details>
 
 ### To-Python conversions changed for byte collections (`Vec<u8>`, `[u8; N]` and `SmallVec<[u8; N]>`).
-<details open>
+<details>
 <summary><small>Click to expand</small></summary>
 
 With the introduction of the `IntoPyObject` trait, PyO3's macros now prefer `IntoPyObject` implementations over `IntoPy<PyObject>` when producing Python values. This applies to `#[pyfunction]` and `#[pymethods]` return values and also fields accessed via `#[pyo3(get)]`.
@@ -170,7 +187,7 @@ This is purely additional and should just extend the possible return types.
 </details>
 
 ### `gil-refs` feature removed
-<details open>
+<details>
 <summary><small>Click to expand</small></summary>
 
 PyO3 0.23 completes the removal of the "GIL Refs" API in favour of the new "Bound" API introduced in PyO3 0.21.
diff --git a/guide/src/module.md b/guide/src/module.md
index deb516d9c97..fa756e85920 100644
--- a/guide/src/module.md
+++ b/guide/src/module.md
@@ -124,6 +124,9 @@ mod my_extension {
     #[pymodule_export]
     use super::double; // Exports the double function as part of the module
 
+    #[pymodule_export]
+    const PI: f64 = std::f64::consts::PI; // Exports PI constant as part of the module
+
     #[pyfunction] // This will be part of the module
     fn triple(x: usize) -> usize {
         x * 3
diff --git a/guide/src/python-from-rust/function-calls.md b/guide/src/python-from-rust/function-calls.md
index 2e5cf3c589e..b64c062eec7 100644
--- a/guide/src/python-from-rust/function-calls.md
+++ b/guide/src/python-from-rust/function-calls.md
@@ -59,13 +59,13 @@ fn main() -> PyResult<()> {
 
 ## Creating keyword arguments
 
-For the `call` and `call_method` APIs, `kwargs` are `Option<&Bound<'py, PyDict>>`, so can either be `None` or `Some(&dict)`. You can use the [`IntoPyDict`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.IntoPyDict.html) trait to convert other dict-like containers, e.g. `HashMap` or `BTreeMap`, as well as tuples with up to 10 elements and `Vec`s where each element is a two-element tuple.
+For the `call` and `call_method` APIs, `kwargs` are `Option<&Bound<'py, PyDict>>`, so can either be `None` or `Some(&dict)`. You can use the [`IntoPyDict`]({{#PYO3_DOCS_URL}}/pyo3/types/trait.IntoPyDict.html) trait to convert other dict-like containers, e.g. `HashMap` or `BTreeMap`, as well as tuples with up to 10 elements and `Vec`s where each element is a two-element tuple. To pass keyword arguments of different types, construct a `PyDict` object.
 
 ```rust
 use pyo3::prelude::*;
-use pyo3::types::IntoPyDict;
+use pyo3::types::{PyDict, IntoPyDict};
 use std::collections::HashMap;
-use pyo3_ffi::c_str;
+use pyo3::ffi::c_str;
 
 fn main() -> PyResult<()> {
     let key1 = "key1";
@@ -102,7 +102,13 @@ fn main() -> PyResult<()> {
         kwargs.insert(key1, 1);
         fun.call(py, (), Some(&kwargs.into_py_dict(py)?))?;
 
+        // pass arguments of different types as PyDict
+        let kwargs = PyDict::new(py);
+        kwargs.set_item(key1, val1)?;
+        kwargs.set_item(key2, "string")?;
+        fun.call(py, (), Some(&kwargs))?;
+
         Ok(())
     })
 }
-```
\ No newline at end of file
+```
diff --git a/guide/src/python-typing-hints.md b/guide/src/python-typing-hints.md
index 43a15a21a6e..eb39bb35fb0 100644
--- a/guide/src/python-typing-hints.md
+++ b/guide/src/python-typing-hints.md
@@ -41,7 +41,7 @@ As we can see, those are not full definitions containing implementation, but jus
 
 ### What do the PEPs say?
 
-At the time of writing this documentation, the `pyi` files are referenced in three PEPs.
+At the time of writing this documentation, the `pyi` files are referenced in four PEPs.
 
 [PEP8 - Style Guide for Python Code - #Function Annotations](https://www.python.org/dev/peps/pep-0008/#function-annotations) (last point) recommends all third party library creators to provide stub files as the source of knowledge about the package for type checker tools.
 
@@ -55,6 +55,8 @@ It contains a specification for them (highly recommended reading, since it conta
 
 [PEP561 - Distributing and Packaging Type Information](https://www.python.org/dev/peps/pep-0561/) describes in detail how to build packages that will enable type checking. In particular it contains information about how the stub files must be distributed in order for type checkers to use them.
 
+[PEP560 - Core support for typing module and generic types](https://www.python.org/dev/peps/pep-0560/) describes the details on how Python's type system internally supports generics, including both runtime behavior and integration with static type checkers.
+
 ## How to do it?
 
 [PEP561](https://www.python.org/dev/peps/pep-0561/) recognizes three ways of distributing type information:
@@ -165,3 +167,77 @@ class Car:
         :return: the name of the color our great algorithm thinks is the best for this car
         """
 ```
+
+### Supporting Generics
+
+Type annotations can also be made generic in Python. They are useful for working
+with different types while maintaining type safety. Usually, generic classes
+inherit from the `typing.Generic` metaclass.
+
+Take for example the following `.pyi` file that specifies a `Car` that can
+accept multiple types of wheels:
+
+```python
+from typing import Generic, TypeVar
+
+W = TypeVar('W')
+
+class Car(Generic[W]):
+    def __init__(self, wheels: list[W]) -> None: ...
+
+    def get_wheels(self) -> list[W]: ...
+
+    def change_wheel(self, wheel_number: int, wheel: W) -> None: ...
+```
+
+This way, the end-user can specify the type with variables such as `truck: Car[SteelWheel] = ...`
+and `f1_car: Car[AlloyWheel] = ...`.
+
+There is also a special syntax for specifying generic types in Python 3.12+:
+
+```python
+class Car[W]:
+    def __init__(self, wheels: list[W]) -> None: ...
+
+    def get_wheels(self) -> list[W]: ...
+```
+
+#### Runtime Behaviour
+
+Stub files (`pyi`) are only useful for static type checkers and ignored at runtime. Therefore,
+PyO3 classes do not inherit from `typing.Generic` even if specified in the stub files.
+
+This can cause some runtime issues, as annotating a variable like `f1_car: Car[AlloyWheel] = ...`
+can make Python call magic methods that are not defined. 
+
+To overcome this limitation, implementers can pass the `generic` parameter to `pyclass` in Rust:
+
+```rust ignore
+#[pyclass(generic)]
+```
+
+#### Advanced Users
+
+`#[pyclass(generic)]` implements a very simple runtime behavior that accepts
+any generic argument. Advanced users can opt to manually implement
+[`__class_geitem__`](https://docs.python.org/3/reference/datamodel.html#emulating-generic-types)
+for the generic class to have more control.
+
+```rust ignore
+impl MyClass {
+    #[classmethod]
+    #[pyo3(signature = (key, /))]
+    pub fn __class_getitem__(
+        cls: &Bound<'_, PyType>,
+        key: &Bound<'_, PyAny>,
+    ) -> PyResult<PyObject> {
+        /* implementation details */
+    }
+}
+```
+
+Note that [`pyo3::types::PyGenericAlias`][pygenericalias] can be helfpul when implementing
+`__class_geitem__` as it can create [`types.GenericAlias`][genericalias] objects from Rust.
+
+[pygenericalias]: {{#PYO3_DOCS_URL}}/pyo3/types/struct.pygenericalias
+[genericalias]: https://docs.python.org/3/library/types.html#types.GenericAlias
\ No newline at end of file
diff --git a/newsfragments/3977.added.md b/newsfragments/3977.added.md
deleted file mode 100644
index 58f116cd837..00000000000
--- a/newsfragments/3977.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Basic introspection and stub generation based on metadata embedded in produced cdylib.
\ No newline at end of file
diff --git a/newsfragments/4969.added.md b/newsfragments/4969.added.md
deleted file mode 100644
index 7a59e9aef6f..00000000000
--- a/newsfragments/4969.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Added `abi3-py313` feature
\ No newline at end of file
diff --git a/newsfragments/4970.changed.md b/newsfragments/4970.changed.md
deleted file mode 100644
index 7ea1b6ae0cd..00000000000
--- a/newsfragments/4970.changed.md
+++ /dev/null
@@ -1 +0,0 @@
-- Make `datetime` rust wrappers compatible with `abi3` feature
diff --git a/newsfragments/4978.added.md b/newsfragments/4978.added.md
deleted file mode 100644
index 5518cee89d8..00000000000
--- a/newsfragments/4978.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Implement getattr_opt in `PyAnyMethods`
\ No newline at end of file
diff --git a/newsfragments/4981.fixed.md b/newsfragments/4981.fixed.md
deleted file mode 100644
index 0ac31b19a11..00000000000
--- a/newsfragments/4981.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix `is_type_of` for native types not using same specialized check as `is_type_of_bound`.
diff --git a/newsfragments/4982.removed.md b/newsfragments/4982.removed.md
deleted file mode 100644
index 61f9dedbc48..00000000000
--- a/newsfragments/4982.removed.md
+++ /dev/null
@@ -1 +0,0 @@
-Remove all functionality deprecated in PyO3 0.23.
diff --git a/newsfragments/4984.added.md b/newsfragments/4984.added.md
deleted file mode 100644
index 63559617812..00000000000
--- a/newsfragments/4984.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Added PyInt constructor for all supported number types (i32, u32, i64, u64, isize, usize)
\ No newline at end of file
diff --git a/newsfragments/4988.fixed.md b/newsfragments/4988.fixed.md
deleted file mode 100644
index 1a050b905e3..00000000000
--- a/newsfragments/4988.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix `Probe` class naming issue with `#[pymethods]`
diff --git a/newsfragments/4992.added.md b/newsfragments/4992.added.md
deleted file mode 100644
index 36cb9a4e08e..00000000000
--- a/newsfragments/4992.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Add `pyo3::sync::with_critical_section2` binding
diff --git a/newsfragments/5002.fixed.md b/newsfragments/5002.fixed.md
deleted file mode 100644
index ad9b0091a79..00000000000
--- a/newsfragments/5002.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix compile failure with required `#[pyfunction]` arguments taking `Option<&str>` and `Option<&T>` (for `#[pyclass]` types).
diff --git a/newsfragments/5008.fixed.md b/newsfragments/5008.fixed.md
deleted file mode 100644
index 6b431d6e437..00000000000
--- a/newsfragments/5008.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix `PyString::from_object`, avoid out of bounds reads by null terminating the `encoding` and `errors` parameters
\ No newline at end of file
diff --git a/newsfragments/5010.removed.md b/newsfragments/5010.removed.md
deleted file mode 100644
index 9b42e682154..00000000000
--- a/newsfragments/5010.removed.md
+++ /dev/null
@@ -1 +0,0 @@
-Remove deprecated `IntoPy` and `ToPyObject` traits
\ No newline at end of file
diff --git a/newsfragments/5011.added.md b/newsfragments/5011.added.md
deleted file mode 100644
index 741a25b3707..00000000000
--- a/newsfragments/5011.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Added conversion support for `bigdecimal::BigDecimal` to and from python `Decimal` type
\ No newline at end of file
diff --git a/newsfragments/5013.added.md b/newsfragments/5013.added.md
deleted file mode 100644
index 0becc3ee1e9..00000000000
--- a/newsfragments/5013.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Implement `PyCallArgs` for `Borrowed<'_, 'py, PyTuple>`, `&Bound<'py, PyTuple>`, and `&Py<PyTuple>`.
diff --git a/newsfragments/5015.fixed.md b/newsfragments/5015.fixed.md
deleted file mode 100644
index b1da048828f..00000000000
--- a/newsfragments/5015.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixes compile error if more options followed after `crate` for `#[pyfunction]`.
\ No newline at end of file
diff --git a/newsfragments/5030.fixed.md b/newsfragments/5030.fixed.md
deleted file mode 100644
index 4cd23405a6c..00000000000
--- a/newsfragments/5030.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixes accidentally emitting `unused_imports` lint in `macro_rules` context.
\ No newline at end of file
diff --git a/newsfragments/5037.fixed.md b/newsfragments/5037.fixed.md
deleted file mode 100644
index 770a136f4f1..00000000000
--- a/newsfragments/5037.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Ensure we correctly pick up the shared state for conda-based Python installation when reading information from sysconfigdata.
diff --git a/newsfragments/5048.fixed.md b/newsfragments/5048.fixed.md
deleted file mode 100644
index de3f79812b1..00000000000
--- a/newsfragments/5048.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix size of `PyCodeObject::_co_instrumentation_version` ffi struct member on Python 3.13 for systems where `uintptr_t` is not 64 bits.
diff --git a/newsfragments/5050.fixed.md b/newsfragments/5050.fixed.md
deleted file mode 100644
index 576809467c6..00000000000
--- a/newsfragments/5050.fixed.md
+++ /dev/null
@@ -1 +0,0 @@
-Fix struct-type complex enum variant fields exposing raw identifiers as `r#ident` in Python bindings.
diff --git a/newsfragments/5054.added.md b/newsfragments/5054.added.md
deleted file mode 100644
index 1400624a577..00000000000
--- a/newsfragments/5054.added.md
+++ /dev/null
@@ -1 +0,0 @@
-Implement `From`/`Into` for `Borrowed<T>` -> `Py<T>`
diff --git a/newsfragments/5121.added.md b/newsfragments/5121.added.md
new file mode 100644
index 00000000000..fd79e5a8ea7
--- /dev/null
+++ b/newsfragments/5121.added.md
@@ -0,0 +1 @@
+Add `PyBytes_AS_STRING`
diff --git a/newsfragments/5121.changed.md b/newsfragments/5121.changed.md
new file mode 100644
index 00000000000..49b317cb96b
--- /dev/null
+++ b/newsfragments/5121.changed.md
@@ -0,0 +1,2 @@
+Enable vectorcall methods on GraalPy
+Call Py_Is function on GraalPy
diff --git a/noxfile.py b/noxfile.py
index f17d40aff14..94e0f392044 100644
--- a/noxfile.py
+++ b/noxfile.py
@@ -19,7 +19,6 @@
     List,
     Optional,
     Tuple,
-    Generator,
 )
 
 
@@ -72,6 +71,9 @@ def _supported_interpreter_versions(
     min_minor = int(min_version.split(".")[1])
     max_minor = int(max_version.split(".")[1])
     versions = [f"{major}.{minor}" for minor in range(min_minor, max_minor + 1)]
+    # Add free-threaded builds for 3.13+
+    if python_impl == "cpython":
+        versions += [f"{major}.{minor}t" for minor in range(13, max_minor + 1)]
     return versions
 
 
@@ -90,17 +92,49 @@ def test_rust(session: nox.Session):
     _run_cargo_test(session, package="pyo3-build-config")
     _run_cargo_test(session, package="pyo3-macros-backend")
     _run_cargo_test(session, package="pyo3-macros")
-    _run_cargo_test(session, package="pyo3-ffi")
 
-    _run_cargo_test(session)
-    # the free-threaded build ignores abi3, so we skip abi3
-    # tests to avoid unnecessarily running the tests twice
-    if not FREE_THREADED_BUILD:
-        _run_cargo_test(session, features="abi3")
-    if "skip-full" not in session.posargs:
-        _run_cargo_test(session, features="full jiff-02")
-        if not FREE_THREADED_BUILD:
-            _run_cargo_test(session, features="abi3 full jiff-02")
+    extra_flags = []
+    # pypy and graalpy don't have Py_Initialize APIs, so we can only
+    # build the main tests, not run them
+    if sys.implementation.name in ("pypy", "graalpy"):
+        extra_flags.append("--no-run")
+
+    _run_cargo_test(session, package="pyo3-ffi", extra_flags=extra_flags)
+
+    extra_flags.append("--no-default-features")
+
+    for feature_set in _get_feature_sets():
+        flags = extra_flags.copy()
+        print(feature_set)
+
+        if feature_set is None or "full" not in feature_set:
+            # doctests require at least the macros feature, which is
+            # activated by the full feature set
+            #
+            # using `--all-targets` makes cargo run everything except doctests
+            flags.append("--all-targets")
+
+        # We need to pass the feature set to the test command
+        # so that it can be used in the test code
+        # (e.g. for `#[cfg(feature = "abi3-py37")]`)
+        if feature_set and "abi3" in feature_set and FREE_THREADED_BUILD:
+            # free-threaded builds don't support abi3 yet
+            continue
+
+        _run_cargo_test(session, features=feature_set, extra_flags=flags)
+
+        if (
+            feature_set
+            and "abi3" in feature_set
+            and "full" in feature_set
+            and sys.version_info >= (3, 7)
+        ):
+            # run abi3-py37 tests to check abi3 forward compatibility
+            _run_cargo_test(
+                session,
+                features=feature_set.replace("abi3", "abi3-py37"),
+                extra_flags=flags,
+            )
 
 
 @nox.session(name="test-py", venv_backend="none")
@@ -179,7 +213,8 @@ def _clippy(session: nox.Session, *, env: Dict[str, str] = None) -> bool:
             _run_cargo(
                 session,
                 "clippy",
-                *feature_set,
+                "--no-default-features",
+                *((f"--features={feature_set}",) if feature_set else ()),
                 "--all-targets",
                 "--workspace",
                 "--",
@@ -256,7 +291,8 @@ def _check(env: Dict[str, str]) -> None:
                 _run_cargo(
                     session,
                     "check",
-                    *feature_set,
+                    "--no-default-features",
+                    *((f"--features={feature_set}",) if feature_set else ()),
                     "--all-targets",
                     "--workspace",
                     env=env,
@@ -426,6 +462,10 @@ def docs(session: nox.Session) -> None:
 
     features = "full"
 
+    if get_rust_version()[:2] >= (1, 67):
+        # time needs MSRC 1.67+
+        features += ",time"
+
     if get_rust_version()[:2] >= (1, 70):
         # jiff needs MSRC 1.70+
         features += ",jiff-02"
@@ -486,6 +526,7 @@ def check_guide(session: nox.Session):
         "--include-fragments",
         str(PYO3_GUIDE_SRC),
         *remap_args,
+        "--accept=200,429",
         *session.posargs,
     )
     # check external links in the docs
@@ -497,6 +538,7 @@ def check_guide(session: nox.Session):
         *remap_args,
         f"--exclude=file://{PYO3_DOCS_TARGET}",
         "--exclude=http://www.adobe.com/",
+        "--accept=200,429",
         *session.posargs,
     )
 
@@ -701,11 +743,11 @@ def test_version_limits(session: nox.Session):
         config_file.set("CPython", "3.6")
         _run_cargo(session, "check", env=env, expect_error=True)
 
-        assert "3.14" not in PY_VERSIONS
-        config_file.set("CPython", "3.14")
+        assert "3.15" not in PY_VERSIONS
+        config_file.set("CPython", "3.15")
         _run_cargo(session, "check", env=env, expect_error=True)
 
-        # 3.14 CPython should build with forward compatibility
+        # 3.15 CPython should build with forward compatibility
         env["PYO3_USE_ABI3_FORWARD_COMPATIBILITY"] = "1"
         _run_cargo(session, "check", env=env)
 
@@ -725,7 +767,10 @@ def check_feature_powerset(session: nox.Session):
 
     cargo_toml = toml.loads((PYO3_DIR / "Cargo.toml").read_text())
 
-    EXPECTED_ABI3_FEATURES = {f"abi3-py3{ver.split('.')[1]}" for ver in PY_VERSIONS}
+    # free-threaded builds do not support ABI3 (yet)
+    EXPECTED_ABI3_FEATURES = {
+        f"abi3-py3{ver.split('.')[1]}" for ver in PY_VERSIONS if not ver.endswith("t")
+    }
 
     EXCLUDED_FROM_FULL = {
         "nightly",
@@ -813,8 +858,8 @@ def update_ui_tests(session: nox.Session):
     env["TRYBUILD"] = "overwrite"
     command = ["test", "--test", "test_compile_error"]
     _run_cargo(session, *command, env=env)
-    _run_cargo(session, *command, "--features=full,jiff-02", env=env)
-    _run_cargo(session, *command, "--features=abi3,full,jiff-02", env=env)
+    _run_cargo(session, *command, "--features=full,jiff-02,time", env=env)
+    _run_cargo(session, *command, "--features=abi3,full,jiff-02,time", env=env)
 
 
 @nox.session(name="test-introspection")
@@ -860,6 +905,13 @@ def get_rust_version() -> Tuple[int, int, int, List[str]]:
             return (*map(int, version_number.split(".")), extra)
 
 
+def is_rust_nightly() -> bool:
+    for line in _get_rust_info():
+        if line.startswith(_RELEASE_LINE_START):
+            return line.strip().endswith("-nightly")
+    return False
+
+
 def _get_rust_default_target() -> str:
     for line in _get_rust_info():
         if line.startswith(_HOST_LINE_START):
@@ -867,30 +919,28 @@ def _get_rust_default_target() -> str:
 
 
 @lru_cache()
-def _get_feature_sets() -> Generator[Tuple[str, ...], None, None]:
-    """Returns feature sets to use for clippy job"""
+def _get_feature_sets() -> Tuple[Optional[str], ...]:
+    """Returns feature sets to use for Rust jobs"""
     cargo_target = os.getenv("CARGO_BUILD_TARGET", "")
 
-    yield from (
-        ("--no-default-features",),
-        (
-            "--no-default-features",
-            "--features=abi3",
-        ),
-    )
-
     features = "full"
 
     if "wasm32-wasip1" not in cargo_target:
         # multiple-pymethods not supported on wasm
         features += ",multiple-pymethods"
 
+    if get_rust_version()[:2] >= (1, 67):
+        # time needs MSRC 1.67+
+        features += ",time"
+
     if get_rust_version()[:2] >= (1, 70):
         # jiff needs MSRC 1.70+
         features += ",jiff-02"
 
-    yield (f"--features={features}",)
-    yield (f"--features=abi3,{features}",)
+    if is_rust_nightly():
+        features += ",nightly"
+
+    return (None, "abi3", features, f"abi3,{features}")
 
 
 _RELEASE_LINE_START = "release: "
@@ -954,19 +1004,24 @@ def _run_cargo_test(
     package: Optional[str] = None,
     features: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
+    extra_flags: Optional[List[str]] = None,
 ) -> None:
     command = ["cargo"]
     if "careful" in session.posargs:
         # do explicit setup so failures in setup can be seen
         _run_cargo(session, "careful", "setup")
         command.append("careful")
+
     command.extend(("test", "--no-fail-fast"))
+
     if "release" in session.posargs:
         command.append("--release")
     if package:
         command.append(f"--package={package}")
     if features:
         command.append(f"--features={features}")
+    if extra_flags:
+        command.extend(extra_flags)
 
     _run(session, *command, external=True, env=env or {})
 
@@ -1015,6 +1070,11 @@ def set(
         self, implementation: str, version: str, build_flags: Iterable[str] = ()
     ) -> None:
         """Set the contents of this config file to the given implementation and version."""
+        if version.endswith("t"):
+            # Free threaded versions pass the support in config file through a flag
+            version = version[:-1]
+            build_flags = (*build_flags, "Py_GIL_DISABLED")
+
         self._config_file.seek(0)
         self._config_file.truncate(0)
         self._config_file.write(
diff --git a/pyo3-build-config/Cargo.toml b/pyo3-build-config/Cargo.toml
index 86456e33cb5..8070860a1e9 100644
--- a/pyo3-build-config/Cargo.toml
+++ b/pyo3-build-config/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-build-config"
-version = "0.25.0-dev"
+version = "0.25.0"
 description = "Build configuration for the PyO3 ecosystem"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -38,7 +38,8 @@ abi3-py39 = ["abi3-py310"]
 abi3-py310 = ["abi3-py311"]
 abi3-py311 = ["abi3-py312"]
 abi3-py312 = ["abi3-py313"]
-abi3-py313 = ["abi3"]
+abi3-py313 = ["abi3-py314"]
+abi3-py314 = ["abi3"]
 
 [package.metadata.docs.rs]
 features = ["resolve-config"]
diff --git a/pyo3-build-config/src/errors.rs b/pyo3-build-config/src/errors.rs
index 87c59a998b4..b11d02fd581 100644
--- a/pyo3-build-config/src/errors.rs
+++ b/pyo3-build-config/src/errors.rs
@@ -68,7 +68,7 @@ impl std::fmt::Display for ErrorReport<'_> {
             writeln!(f, "\ncaused by:")?;
             let mut index = 0;
             while let Some(some_source) = source {
-                writeln!(f, "  - {}: {}", index, some_source)?;
+                writeln!(f, "  - {index}: {some_source}")?;
                 source = some_source.source();
                 index += 1;
             }
diff --git a/pyo3-build-config/src/impl_.rs b/pyo3-build-config/src/impl_.rs
index 96eb67657ea..9485b8a0394 100644
--- a/pyo3-build-config/src/impl_.rs
+++ b/pyo3-build-config/src/impl_.rs
@@ -58,7 +58,7 @@ pub fn cargo_env_var(var: &str) -> Option<String> {
 /// the variable changes.
 pub fn env_var(var: &str) -> Option<OsString> {
     if cfg!(feature = "resolve-config") {
-        println!("cargo:rerun-if-env-changed={}", var);
+        println!("cargo:rerun-if-env-changed={var}");
     }
     #[cfg(test)]
     {
@@ -180,7 +180,7 @@ impl InterpreterConfig {
         let mut out = vec![];
 
         for i in MINIMUM_SUPPORTED_VERSION.minor..=self.version.minor {
-            out.push(format!("cargo:rustc-cfg=Py_3_{}", i));
+            out.push(format!("cargo:rustc-cfg=Py_3_{i}"));
         }
 
         match self.implementation {
@@ -199,7 +199,7 @@ impl InterpreterConfig {
                 BuildFlag::Py_GIL_DISABLED => {
                     out.push("cargo:rustc-cfg=Py_GIL_DISABLED".to_owned())
                 }
-                flag => out.push(format!("cargo:rustc-cfg=py_sys_config=\"{}\"", flag)),
+                flag => out.push(format!("cargo:rustc-cfg=py_sys_config=\"{flag}\"")),
             }
         }
 
@@ -338,7 +338,7 @@ print("gil_disabled", get_config_var("Py_GIL_DISABLED"))
 
         let lib_dir = if cfg!(windows) {
             map.get("base_prefix")
-                .map(|base_prefix| format!("{}\\libs", base_prefix))
+                .map(|base_prefix| format!("{base_prefix}\\libs"))
         } else {
             map.get("libdir").cloned()
         };
@@ -666,7 +666,7 @@ print("gil_disabled", get_config_var("Py_GIL_DISABLED"))
         write_option_line!(python_framework_prefix)?;
         write_line!(suppress_build_script_link_lines)?;
         for line in &self.extra_build_script_lines {
-            writeln!(writer, "extra_build_script_line={}", line)
+            writeln!(writer, "extra_build_script_line={line}")
                 .context("failed to write extra_build_script_line")?;
         }
         Ok(())
@@ -853,7 +853,7 @@ fn is_abi3() -> bool {
 /// Must be called from a PyO3 crate build script.
 pub fn get_abi3_version() -> Option<PythonVersion> {
     let minor_version = (MINIMUM_SUPPORTED_VERSION.minor..=ABI3_MAX_MINOR)
-        .find(|i| cargo_env_var(&format!("CARGO_FEATURE_ABI3_PY3{}", i)).is_some());
+        .find(|i| cargo_env_var(&format!("CARGO_FEATURE_ABI3_PY3{i}")).is_some());
     minor_version.map(|minor| PythonVersion { major: 3, minor })
 }
 
@@ -1121,8 +1121,8 @@ pub enum BuildFlag {
 impl Display for BuildFlag {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            BuildFlag::Other(flag) => write!(f, "{}", flag),
-            _ => write!(f, "{:?}", self),
+            BuildFlag::Other(flag) => write!(f, "{flag}"),
+            _ => write!(f, "{self:?}"),
         }
     }
 }
@@ -1202,7 +1202,7 @@ impl BuildFlags {
 
         for k in &BuildFlags::ALL {
             use std::fmt::Write;
-            writeln!(&mut script, "print(config.get('{}', '0'))", k).unwrap();
+            writeln!(&mut script, "print(config.get('{k}', '0'))").unwrap();
         }
 
         let stdout = run_python_script(interpreter.as_ref(), &script)?;
@@ -1240,7 +1240,7 @@ impl Display for BuildFlags {
             } else {
                 write!(f, ",")?;
             }
-            write!(f, "{}", flag)?;
+            write!(f, "{flag}")?;
         }
         Ok(())
     }
@@ -1427,7 +1427,7 @@ pub fn find_all_sysconfigdata(cross: &CrossCompileConfig) -> Result<Vec<PathBuf>
 
 fn is_pypy_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
     let pypy_version_pat = if let Some(v) = v {
-        format!("pypy{}", v)
+        format!("pypy{v}")
     } else {
         "pypy3.".into()
     };
@@ -1436,7 +1436,7 @@ fn is_pypy_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
 
 fn is_graalpy_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
     let graalpy_version_pat = if let Some(v) = v {
-        format!("graalpy{}", v)
+        format!("graalpy{v}")
     } else {
         "graalpy2".into()
     };
@@ -1445,7 +1445,7 @@ fn is_graalpy_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
 
 fn is_cpython_lib_dir(path: &str, v: &Option<PythonVersion>) -> bool {
     let cpython_version_pat = if let Some(v) = v {
-        format!("python{}", v)
+        format!("python{v}")
     } else {
         "python3.".into()
     };
@@ -1759,7 +1759,7 @@ fn default_lib_name_unix(
 ) -> Result<String> {
     match implementation {
         PythonImplementation::CPython => match ld_version {
-            Some(ld_version) => Ok(format!("python{}", ld_version)),
+            Some(ld_version) => Ok(format!("python{ld_version}")),
             None => {
                 if version > PythonVersion::PY37 {
                     // PEP 3149 ABI version tags are finally gone
@@ -1776,7 +1776,7 @@ fn default_lib_name_unix(
             }
         },
         PythonImplementation::PyPy => match ld_version {
-            Some(ld_version) => Ok(format!("pypy{}-c", ld_version)),
+            Some(ld_version) => Ok(format!("pypy{ld_version}-c")),
             None => Ok(format!("pypy{}.{}-c", version.major, version.minor)),
         },
 
diff --git a/pyo3-build-config/src/lib.rs b/pyo3-build-config/src/lib.rs
index 68d597a8f2e..f47c16f425d 100644
--- a/pyo3-build-config/src/lib.rs
+++ b/pyo3-build-config/src/lib.rs
@@ -46,7 +46,7 @@ use target_lexicon::OperatingSystem;
 pub fn use_pyo3_cfgs() {
     print_expected_cfgs();
     for cargo_command in get().build_script_outputs() {
-        println!("{}", cargo_command)
+        println!("{cargo_command}")
     }
 }
 
@@ -102,12 +102,7 @@ fn _add_python_framework_link_args(
 ) {
     if matches!(triple.operating_system, OperatingSystem::Darwin(_)) && link_libpython {
         if let Some(framework_prefix) = interpreter_config.python_framework_prefix.as_ref() {
-            writeln!(
-                writer,
-                "cargo:rustc-link-arg=-Wl,-rpath,{}",
-                framework_prefix
-            )
-            .unwrap();
+            writeln!(writer, "cargo:rustc-link-arg=-Wl,-rpath,{framework_prefix}").unwrap();
         }
     }
 }
@@ -173,12 +168,12 @@ fn print_feature_cfg(minor_version_required: u32, cfg: &str) {
     let minor_version = rustc_minor_version().unwrap_or(0);
 
     if minor_version >= minor_version_required {
-        println!("cargo:rustc-cfg={}", cfg);
+        println!("cargo:rustc-cfg={cfg}");
     }
 
     // rustc 1.80.0 stabilized `rustc-check-cfg` feature, don't emit before
     if minor_version >= 80 {
-        println!("cargo:rustc-check-cfg=cfg({})", cfg);
+        println!("cargo:rustc-check-cfg=cfg({cfg})");
     }
 }
 
@@ -221,8 +216,7 @@ pub fn print_expected_cfgs() {
 
     // allow `Py_3_*` cfgs from the minimum supported version up to the
     // maximum minor version (+1 for development for the next)
-    // FIXME: support cfg(Py_3_14) as well due to PyGILState_Ensure
-    for i in impl_::MINIMUM_SUPPORTED_VERSION.minor..=std::cmp::max(14, impl_::ABI3_MAX_MINOR + 1) {
+    for i in impl_::MINIMUM_SUPPORTED_VERSION.minor..=impl_::ABI3_MAX_MINOR + 1 {
         println!("cargo:rustc-check-cfg=cfg(Py_3_{i})");
     }
 }
diff --git a/pyo3-ffi-check/build.rs b/pyo3-ffi-check/build.rs
index 67808888e1e..e7cfbe40df3 100644
--- a/pyo3-ffi-check/build.rs
+++ b/pyo3-ffi-check/build.rs
@@ -1,6 +1,24 @@
 use std::env;
 use std::path::PathBuf;
 
+#[derive(Debug)]
+struct ParseCallbacks;
+
+impl bindgen::callbacks::ParseCallbacks for ParseCallbacks {
+    // these are anonymous fields and structs in CPython that we needed to
+    // invent names for. Bindgen seems to generate stable names, so we remap the
+    // automatically generated names to the names we invented in the FFI
+    fn item_name(&self, _original_item_name: &str) -> Option<String> {
+        if _original_item_name == "_object__bindgen_ty_1__bindgen_ty_1" {
+            Some("PyObjectObFlagsAndRefcnt".into())
+        } else if _original_item_name == "_object__bindgen_ty_1" {
+            Some("PyObjectObRefcnt".into())
+        } else {
+            None
+        }
+    }
+}
+
 fn main() {
     let config = pyo3_build_config::get();
     let python_include_dir = config
@@ -29,6 +47,7 @@ fn main() {
         .header("wrapper.h")
         .clang_args(clang_args)
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .parse_callbacks(Box::new(ParseCallbacks))
         // blocklist some values which apparently have conflicting definitions on unix
         .blocklist_item("FP_NORMAL")
         .blocklist_item("FP_SUBNORMAL")
diff --git a/pyo3-ffi-check/macro/src/lib.rs b/pyo3-ffi-check/macro/src/lib.rs
index c6cee5c7ec3..41092b9020e 100644
--- a/pyo3-ffi-check/macro/src/lib.rs
+++ b/pyo3-ffi-check/macro/src/lib.rs
@@ -9,11 +9,6 @@ const PY_3_12: PythonVersion = PythonVersion {
     minor: 12,
 };
 
-const PY_3_13: PythonVersion = PythonVersion {
-    major: 3,
-    minor: 13,
-};
-
 /// Macro which expands to multiple macro calls, one per pyo3-ffi struct.
 #[proc_macro]
 pub fn for_all_structs(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -55,16 +50,6 @@ pub fn for_all_structs(input: proc_macro::TokenStream) -> proc_macro::TokenStrea
             .strip_suffix(".html")
             .unwrap();
 
-        if struct_name == "_PyCoLineInstrumentationData"
-            && pyo3_build_config::get().version == PY_3_13
-        {
-            // private type, fields changed name in 3.13.2 -> 3.13.3
-            //
-            // PyO3 0.25 will remove this struct, ignoring temporarily just to unblock CI
-            // changed, the size stayed the same.
-            continue;
-        }
-
         let struct_ident = Ident::new(struct_name, Span::call_site());
         output.extend(quote!(#macro_name!(#struct_ident);));
     }
diff --git a/pyo3-ffi/Cargo.toml b/pyo3-ffi/Cargo.toml
index 8b75c978c2e..647b76fbdcd 100644
--- a/pyo3-ffi/Cargo.toml
+++ b/pyo3-ffi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-ffi"
-version = "0.25.0-dev"
+version = "0.25.0"
 description = "Python-API bindings for the PyO3 ecosystem"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -34,7 +34,8 @@ abi3-py39 = ["abi3-py310", "pyo3-build-config/abi3-py39"]
 abi3-py310 = ["abi3-py311", "pyo3-build-config/abi3-py310"]
 abi3-py311 = ["abi3-py312", "pyo3-build-config/abi3-py311"]
 abi3-py312 = ["abi3-py313", "pyo3-build-config/abi3-py312"]
-abi3-py313 = ["abi3", "pyo3-build-config/abi3-py313"]
+abi3-py313 = ["abi3-py314", "pyo3-build-config/abi3-py313"]
+abi3-py314 = ["abi3", "pyo3-build-config/abi3-py314"]
 
 # Automatically generates `python3.dll` import libraries for Windows targets.
 generate-import-lib = ["pyo3-build-config/python3-dll-a"]
@@ -43,14 +44,14 @@ generate-import-lib = ["pyo3-build-config/python3-dll-a"]
 paste = "1"
 
 [build-dependencies]
-pyo3-build-config = { path = "../pyo3-build-config", version = "=0.25.0-dev", features = ["resolve-config"] }
+pyo3-build-config = { path = "../pyo3-build-config", version = "=0.25.0", features = ["resolve-config"] }
 
 [lints]
 workspace = true
 
 [package.metadata.cpython]
 min-version = "3.7"
-max-version = "3.13"  # inclusive
+max-version = "3.14"  # inclusive
 
 [package.metadata.pypy]
 min-version = "3.9"
diff --git a/pyo3-ffi/README.md b/pyo3-ffi/README.md
index e817a1a73d7..09be0a06f66 100644
--- a/pyo3-ffi/README.md
+++ b/pyo3-ffi/README.md
@@ -41,13 +41,13 @@ name = "string_sum"
 crate-type = ["cdylib"]
 
 [dependencies.pyo3-ffi]
-version = "0.24.0"
+version = "0.25.0"
 features = ["extension-module"]
 
 [build-dependencies]
 # This is only necessary if you need to configure your build based on
 # the Python version or the compile-time configuration for the interpreter.
-pyo3_build_config = "0.24.0"
+pyo3_build_config = "0.25.0"
 ```
 
 If you need to use conditional compilation based on Python version or how
diff --git a/pyo3-ffi/build.rs b/pyo3-ffi/build.rs
index 096614c7961..6776cd80476 100644
--- a/pyo3-ffi/build.rs
+++ b/pyo3-ffi/build.rs
@@ -17,7 +17,7 @@ const SUPPORTED_VERSIONS_CPYTHON: SupportedVersions = SupportedVersions {
     min: PythonVersion { major: 3, minor: 7 },
     max: PythonVersion {
         major: 3,
-        minor: 13,
+        minor: 14,
     },
 };
 
@@ -176,7 +176,7 @@ fn emit_link_config(interpreter_config: &InterpreterConfig) -> Result<()> {
     );
 
     if let Some(lib_dir) = &interpreter_config.lib_dir {
-        println!("cargo:rustc-link-search=native={}", lib_dir);
+        println!("cargo:rustc-link-search=native={lib_dir}");
     }
 
     Ok(())
@@ -207,12 +207,12 @@ fn configure_pyo3() -> Result<()> {
     }
 
     for cfg in interpreter_config.build_script_outputs() {
-        println!("{}", cfg)
+        println!("{cfg}")
     }
 
     // Extra lines come last, to support last write wins.
     for line in &interpreter_config.extra_build_script_lines {
-        println!("{}", line);
+        println!("{line}");
     }
 
     // Emit cfgs like `invalid_from_utf8_lint`
diff --git a/pyo3-ffi/src/abstract_.rs b/pyo3-ffi/src/abstract_.rs
index a79ec43f271..59639d14de8 100644
--- a/pyo3-ffi/src/abstract_.rs
+++ b/pyo3-ffi/src/abstract_.rs
@@ -93,7 +93,7 @@ extern "C" {
         kwnames: *mut PyObject,
     ) -> *mut PyObject;
 
-    #[cfg(any(Py_3_12, all(Py_3_9, not(any(Py_LIMITED_API, PyPy, GraalPy)))))]
+    #[cfg(any(Py_3_12, all(Py_3_9, not(any(Py_LIMITED_API, PyPy)))))]
     pub fn PyObject_VectorcallMethod(
         name: *mut PyObject,
         args: *const *mut PyObject,
diff --git a/pyo3-ffi/src/bytearrayobject.rs b/pyo3-ffi/src/bytearrayobject.rs
index 24a97bcc31b..d27dfa8b0ec 100644
--- a/pyo3-ffi/src/bytearrayobject.rs
+++ b/pyo3-ffi/src/bytearrayobject.rs
@@ -17,7 +17,7 @@ pub struct PyByteArrayObject {
 }
 
 #[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
-opaque_struct!(PyByteArrayObject);
+opaque_struct!(pub PyByteArrayObject);
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
diff --git a/pyo3-ffi/src/code.rs b/pyo3-ffi/src/code.rs
index d28f68cded7..296b17f6aa4 100644
--- a/pyo3-ffi/src/code.rs
+++ b/pyo3-ffi/src/code.rs
@@ -1,4 +1,4 @@
 // This header doesn't exist in CPython, but Include/cpython/code.h does. We add
 // this here so that PyCodeObject has a definition under the limited API.
 
-opaque_struct!(PyCodeObject);
+opaque_struct!(pub PyCodeObject);
diff --git a/pyo3-ffi/src/compat/mod.rs b/pyo3-ffi/src/compat/mod.rs
index 11f2912848e..044ea46762b 100644
--- a/pyo3-ffi/src/compat/mod.rs
+++ b/pyo3-ffi/src/compat/mod.rs
@@ -52,8 +52,10 @@ macro_rules! compat_function {
 
 mod py_3_10;
 mod py_3_13;
+mod py_3_14;
 mod py_3_9;
 
 pub use self::py_3_10::*;
 pub use self::py_3_13::*;
+pub use self::py_3_14::*;
 pub use self::py_3_9::*;
diff --git a/pyo3-ffi/src/compat/py_3_10.rs b/pyo3-ffi/src/compat/py_3_10.rs
index c6e8c2cb5ca..d962fb3bc7e 100644
--- a/pyo3-ffi/src/compat/py_3_10.rs
+++ b/pyo3-ffi/src/compat/py_3_10.rs
@@ -17,3 +17,29 @@ compat_function!(
         obj
     }
 );
+
+compat_function!(
+    originally_defined_for(Py_3_10);
+
+    #[inline]
+    pub unsafe fn PyModule_AddObjectRef(
+        module: *mut crate::PyObject,
+        name: *const std::os::raw::c_char,
+        value: *mut crate::PyObject,
+    ) -> std::os::raw::c_int {
+        if value.is_null() && crate::PyErr_Occurred().is_null() {
+            crate::PyErr_SetString(
+                crate::PyExc_SystemError,
+                c_str!("PyModule_AddObjectRef() must be called with an exception raised if value is NULL").as_ptr(),
+            );
+            return -1;
+        }
+
+        crate::Py_XINCREF(value);
+        let result = crate::PyModule_AddObject(module, name, value);
+        if result < 0 {
+            crate::Py_XDECREF(value);
+        }
+        result
+    }
+);
diff --git a/pyo3-ffi/src/compat/py_3_13.rs b/pyo3-ffi/src/compat/py_3_13.rs
index 59289cb76ae..96c90e7eb66 100644
--- a/pyo3-ffi/src/compat/py_3_13.rs
+++ b/pyo3-ffi/src/compat/py_3_13.rs
@@ -104,3 +104,18 @@ compat_function!(
         crate::PyList_SetSlice(list, 0, crate::PY_SSIZE_T_MAX, std::ptr::null_mut())
     }
 );
+
+compat_function!(
+    originally_defined_for(Py_3_13);
+
+    #[inline]
+    pub unsafe fn PyModule_Add(
+        module: *mut crate::PyObject,
+        name: *const std::os::raw::c_char,
+        value: *mut crate::PyObject,
+    ) -> std::os::raw::c_int {
+        let result = crate::compat::PyModule_AddObjectRef(module, name, value);
+        crate::Py_XDECREF(value);
+        result
+    }
+);
diff --git a/pyo3-ffi/src/compat/py_3_14.rs b/pyo3-ffi/src/compat/py_3_14.rs
new file mode 100644
index 00000000000..6fdaef17488
--- /dev/null
+++ b/pyo3-ffi/src/compat/py_3_14.rs
@@ -0,0 +1,26 @@
+compat_function!(
+    originally_defined_for(all(Py_3_14, not(Py_LIMITED_API)));
+
+    #[inline]
+    pub unsafe fn Py_HashBuffer(
+        ptr: *const std::ffi::c_void,
+        len: crate::Py_ssize_t,
+    ) -> crate::Py_hash_t {
+        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+        {
+            crate::_Py_HashBytes(ptr, len)
+        }
+
+        #[cfg(any(Py_LIMITED_API, PyPy))]
+        {
+            let bytes = crate::PyBytes_FromStringAndSize(ptr as *const std::os::raw::c_char, len);
+            if bytes.is_null() {
+                -1
+            } else {
+                let result = crate::PyObject_Hash(bytes);
+                crate::Py_DECREF(bytes);
+                result
+            }
+        }
+    }
+);
diff --git a/pyo3-ffi/src/compat/py_3_9.rs b/pyo3-ffi/src/compat/py_3_9.rs
index 285f2b2ae7e..6b3521cc167 100644
--- a/pyo3-ffi/src/compat/py_3_9.rs
+++ b/pyo3-ffi/src/compat/py_3_9.rs
@@ -1,7 +1,6 @@
 compat_function!(
     originally_defined_for(all(
         not(PyPy),
-        not(GraalPy),
         any(Py_3_10, all(not(Py_LIMITED_API), Py_3_9)) // Added to python in 3.9 but to limited API in 3.10
     ));
 
@@ -12,7 +11,7 @@ compat_function!(
 );
 
 compat_function!(
-    originally_defined_for(all(Py_3_9, not(any(Py_LIMITED_API, PyPy, GraalPy))));
+    originally_defined_for(all(Py_3_9, not(any(Py_LIMITED_API, PyPy))));
 
     #[inline]
     pub unsafe fn PyObject_CallMethodNoArgs(obj: *mut crate::PyObject, name: *mut crate::PyObject) -> *mut crate::PyObject {
diff --git a/pyo3-ffi/src/cpython/abstract_.rs b/pyo3-ffi/src/cpython/abstract_.rs
index 6ada1a754ef..b9d9dd47dc9 100644
--- a/pyo3-ffi/src/cpython/abstract_.rs
+++ b/pyo3-ffi/src/cpython/abstract_.rs
@@ -1,12 +1,12 @@
 use crate::{PyObject, Py_ssize_t};
-#[cfg(any(all(Py_3_8, not(any(PyPy, GraalPy))), not(Py_3_11)))]
+#[cfg(any(all(Py_3_8, not(PyPy)), not(Py_3_11)))]
 use std::os::raw::c_char;
 use std::os::raw::c_int;
 
 #[cfg(not(Py_3_11))]
 use crate::Py_buffer;
 
-#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_8, not(PyPy)))]
 use crate::{
     vectorcallfunc, PyCallable_Check, PyThreadState, PyThreadState_GET, PyTuple_Check,
     PyType_HasFeature, Py_TPFLAGS_HAVE_VECTORCALL,
@@ -23,7 +23,7 @@ extern "C" {
 const _PY_FASTCALL_SMALL_STACK: size_t = 5;
 
 extern "C" {
-    #[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+    #[cfg(all(Py_3_8, not(PyPy)))]
     pub fn _Py_CheckFunctionResult(
         tstate: *mut PyThreadState,
         callable: *mut PyObject,
@@ -31,7 +31,7 @@ extern "C" {
         where_: *const c_char,
     ) -> *mut PyObject;
 
-    #[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+    #[cfg(all(Py_3_8, not(PyPy)))]
     pub fn _PyObject_MakeTpCall(
         tstate: *mut PyThreadState,
         callable: *mut PyObject,
@@ -52,7 +52,7 @@ pub unsafe fn PyVectorcall_NARGS(n: size_t) -> Py_ssize_t {
     n.try_into().expect("cannot fail due to mask")
 }
 
-#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_8, not(PyPy)))]
 #[inline(always)]
 pub unsafe fn PyVectorcall_Function(callable: *mut PyObject) -> Option<vectorcallfunc> {
     assert!(!callable.is_null());
@@ -67,7 +67,7 @@ pub unsafe fn PyVectorcall_Function(callable: *mut PyObject) -> Option<vectorcal
     *ptr
 }
 
-#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_8, not(PyPy)))]
 #[inline(always)]
 pub unsafe fn _PyObject_VectorcallTstate(
     tstate: *mut PyThreadState,
@@ -148,7 +148,7 @@ pub unsafe fn _PyObject_FastCall(
     _PyObject_FastCallTstate(PyThreadState_GET(), func, args, nargs)
 }
 
-#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_8, not(PyPy)))]
 #[inline(always)]
 pub unsafe fn _PyObject_CallNoArg(func: *mut PyObject) -> *mut PyObject {
     _PyObject_VectorcallTstate(
@@ -166,7 +166,7 @@ extern "C" {
     pub fn _PyObject_CallNoArg(func: *mut PyObject) -> *mut PyObject;
 }
 
-#[cfg(all(Py_3_8, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_8, not(PyPy)))]
 #[inline(always)]
 pub unsafe fn PyObject_CallOneArg(func: *mut PyObject, arg: *mut PyObject) -> *mut PyObject {
     assert!(!arg.is_null());
@@ -177,7 +177,7 @@ pub unsafe fn PyObject_CallOneArg(func: *mut PyObject, arg: *mut PyObject) -> *m
     _PyObject_VectorcallTstate(tstate, func, args, nargsf, std::ptr::null_mut())
 }
 
-#[cfg(all(Py_3_9, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_9, not(PyPy)))]
 #[inline(always)]
 pub unsafe fn PyObject_CallMethodNoArgs(
     self_: *mut PyObject,
@@ -191,7 +191,7 @@ pub unsafe fn PyObject_CallMethodNoArgs(
     )
 }
 
-#[cfg(all(Py_3_9, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_9, not(PyPy)))]
 #[inline(always)]
 pub unsafe fn PyObject_CallMethodOneArg(
     self_: *mut PyObject,
@@ -219,7 +219,7 @@ extern "C" {
     pub fn PyObject_LengthHint(o: *mut PyObject, arg1: Py_ssize_t) -> Py_ssize_t;
 
     #[cfg(not(Py_3_11))] // moved to src/buffer.rs from 3.11
-    #[cfg(all(Py_3_9, not(any(PyPy, GraalPy))))]
+    #[cfg(all(Py_3_9, not(PyPy)))]
     pub fn PyObject_CheckBuffer(obj: *mut PyObject) -> c_int;
 }
 
diff --git a/pyo3-ffi/src/cpython/bytesobject.rs b/pyo3-ffi/src/cpython/bytesobject.rs
index 306702de25e..9e233311ac1 100644
--- a/pyo3-ffi/src/cpython/bytesobject.rs
+++ b/pyo3-ffi/src/cpython/bytesobject.rs
@@ -1,6 +1,6 @@
 use crate::object::*;
 use crate::Py_ssize_t;
-#[cfg(not(any(PyPy, GraalPy, Py_LIMITED_API)))]
+#[cfg(not(Py_LIMITED_API))]
 use std::os::raw::c_char;
 use std::os::raw::c_int;
 
@@ -17,9 +17,18 @@ pub struct PyBytesObject {
 }
 
 #[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
-opaque_struct!(PyBytesObject);
+opaque_struct!(pub PyBytesObject);
 
 extern "C" {
     #[cfg_attr(PyPy, link_name = "_PyPyBytes_Resize")]
     pub fn _PyBytes_Resize(bytes: *mut *mut PyObject, newsize: Py_ssize_t) -> c_int;
 }
+
+#[cfg(not(Py_LIMITED_API))]
+#[inline]
+pub unsafe fn PyBytes_AS_STRING(op: *mut PyObject) -> *const c_char {
+    #[cfg(not(any(PyPy, GraalPy)))]
+    return &(*op.cast::<PyBytesObject>()).ob_sval as *const c_char;
+    #[cfg(any(PyPy, GraalPy))]
+    return crate::PyBytes_AsString(op);
+}
diff --git a/pyo3-ffi/src/cpython/code.rs b/pyo3-ffi/src/cpython/code.rs
index 60989901052..3d47a1bc8c3 100644
--- a/pyo3-ffi/src/cpython/code.rs
+++ b/pyo3-ffi/src/cpython/code.rs
@@ -1,209 +1,43 @@
 use crate::object::*;
 use crate::pyport::Py_ssize_t;
 
-#[allow(unused_imports)]
-use std::os::raw::{c_char, c_int, c_short, c_uchar, c_void};
+#[cfg(not(GraalPy))]
+use std::os::raw::c_char;
+use std::os::raw::{c_int, c_void};
 #[cfg(not(any(PyPy, GraalPy)))]
 use std::ptr::addr_of_mut;
 
-#[cfg(all(Py_3_8, not(any(PyPy, GraalPy)), not(Py_3_11)))]
-opaque_struct!(_PyOpcache);
+// skipped private _PY_MONITORING_LOCAL_EVENTS
+// skipped private _PY_MONITORING_UNGROUPED_EVENTS
+// skipped private _PY_MONITORING_EVENTS
 
-#[cfg(Py_3_12)]
-pub const _PY_MONITORING_LOCAL_EVENTS: usize = 10;
-#[cfg(Py_3_12)]
-pub const _PY_MONITORING_UNGROUPED_EVENTS: usize = 15;
-#[cfg(Py_3_12)]
-pub const _PY_MONITORING_EVENTS: usize = 17;
+// skipped private _PyLocalMonitors
+// skipped private _Py_GlobalMonitors
 
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct _Py_LocalMonitors {
-    pub tools: [u8; if cfg!(Py_3_13) {
-        _PY_MONITORING_LOCAL_EVENTS
-    } else {
-        _PY_MONITORING_UNGROUPED_EVENTS
-    }],
-}
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct _Py_GlobalMonitors {
-    pub tools: [u8; _PY_MONITORING_UNGROUPED_EVENTS],
-}
-
-// skipped _Py_CODEUNIT
+// skipped private _Py_CODEUNIT
 
-// skipped _Py_OPCODE
-// skipped _Py_OPARG
+// skipped private _Py_OPCODE
+// skipped private _Py_OPARG
 
-// skipped _py_make_codeunit
+// skipped private _py_make_codeunit
 
-// skipped _py_set_opcode
+// skipped private _py_set_opcode
 
-// skipped _Py_MAKE_CODEUNIT
-// skipped _Py_SET_OPCODE
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCoCached {
-    pub _co_code: *mut PyObject,
-    pub _co_varnames: *mut PyObject,
-    pub _co_cellvars: *mut PyObject,
-    pub _co_freevars: *mut PyObject,
-}
-
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCoLineInstrumentationData {
-    pub original_opcode: u8,
-    pub line_delta: i8,
-}
+// skipped private _Py_MAKE_CODEUNIT
+// skipped private _Py_SET_OPCODE
 
-#[cfg(Py_3_12)]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCoMonitoringData {
-    pub local_monitors: _Py_LocalMonitors,
-    pub active_monitors: _Py_LocalMonitors,
-    pub tools: *mut u8,
-    pub lines: *mut _PyCoLineInstrumentationData,
-    pub line_tools: *mut u8,
-    pub per_instruction_opcodes: *mut u8,
-    pub per_instruction_tools: *mut u8,
-}
-
-#[cfg(all(not(any(PyPy, GraalPy)), not(Py_3_7)))]
-opaque_struct!(PyCodeObject);
-
-#[cfg(all(not(any(PyPy, GraalPy)), Py_3_7, not(Py_3_8)))]
-#[repr(C)]
-pub struct PyCodeObject {
-    pub ob_base: PyObject,
-    pub co_argcount: c_int,
-    pub co_kwonlyargcount: c_int,
-    pub co_nlocals: c_int,
-    pub co_stacksize: c_int,
-    pub co_flags: c_int,
-    pub co_firstlineno: c_int,
-    pub co_code: *mut PyObject,
-    pub co_consts: *mut PyObject,
-    pub co_names: *mut PyObject,
-    pub co_varnames: *mut PyObject,
-    pub co_freevars: *mut PyObject,
-    pub co_cellvars: *mut PyObject,
-    pub co_cell2arg: *mut Py_ssize_t,
-    pub co_filename: *mut PyObject,
-    pub co_name: *mut PyObject,
-    pub co_lnotab: *mut PyObject,
-    pub co_zombieframe: *mut c_void,
-    pub co_weakreflist: *mut PyObject,
-    pub co_extra: *mut c_void,
-}
-
-#[cfg(Py_3_13)]
-opaque_struct!(_PyExecutorArray);
-
-#[cfg(all(not(any(PyPy, GraalPy)), Py_3_8, not(Py_3_11)))]
-#[repr(C)]
-pub struct PyCodeObject {
-    pub ob_base: PyObject,
-    pub co_argcount: c_int,
-    pub co_posonlyargcount: c_int,
-    pub co_kwonlyargcount: c_int,
-    pub co_nlocals: c_int,
-    pub co_stacksize: c_int,
-    pub co_flags: c_int,
-    pub co_firstlineno: c_int,
-    pub co_code: *mut PyObject,
-    pub co_consts: *mut PyObject,
-    pub co_names: *mut PyObject,
-    pub co_varnames: *mut PyObject,
-    pub co_freevars: *mut PyObject,
-    pub co_cellvars: *mut PyObject,
-    pub co_cell2arg: *mut Py_ssize_t,
-    pub co_filename: *mut PyObject,
-    pub co_name: *mut PyObject,
-    #[cfg(not(Py_3_10))]
-    pub co_lnotab: *mut PyObject,
-    #[cfg(Py_3_10)]
-    pub co_linetable: *mut PyObject,
-    pub co_zombieframe: *mut c_void,
-    pub co_weakreflist: *mut PyObject,
-    pub co_extra: *mut c_void,
-    pub co_opcache_map: *mut c_uchar,
-    pub co_opcache: *mut _PyOpcache,
-    pub co_opcache_flag: c_int,
-    pub co_opcache_size: c_uchar,
-}
+// skipped private _PyCoCached
+// skipped private _PyCoLineInstrumentationData
+// skipped private _PyCoMontoringData
 
-#[cfg(all(not(any(PyPy, GraalPy)), Py_3_11))]
-#[repr(C)]
-pub struct PyCodeObject {
-    pub ob_base: PyVarObject,
-    pub co_consts: *mut PyObject,
-    pub co_names: *mut PyObject,
-    pub co_exceptiontable: *mut PyObject,
-    pub co_flags: c_int,
-    #[cfg(not(Py_3_12))]
-    pub co_warmup: c_int,
+// skipped private _PyExecutorArray
 
-    pub co_argcount: c_int,
-    pub co_posonlyargcount: c_int,
-    pub co_kwonlyargcount: c_int,
-    pub co_stacksize: c_int,
-    pub co_firstlineno: c_int,
-
-    pub co_nlocalsplus: c_int,
-    #[cfg(Py_3_12)]
-    pub co_framesize: c_int,
-    pub co_nlocals: c_int,
-    #[cfg(not(Py_3_12))]
-    pub co_nplaincellvars: c_int,
-    pub co_ncellvars: c_int,
-    pub co_nfreevars: c_int,
-    #[cfg(Py_3_12)]
-    pub co_version: u32,
-
-    pub co_localsplusnames: *mut PyObject,
-    pub co_localspluskinds: *mut PyObject,
-    pub co_filename: *mut PyObject,
-    pub co_name: *mut PyObject,
-    pub co_qualname: *mut PyObject,
-    pub co_linetable: *mut PyObject,
-    pub co_weakreflist: *mut PyObject,
-    #[cfg(not(Py_3_12))]
-    pub _co_code: *mut PyObject,
-    #[cfg(not(Py_3_12))]
-    pub _co_linearray: *mut c_char,
-    #[cfg(Py_3_13)]
-    pub co_executors: *mut _PyExecutorArray,
-    #[cfg(Py_3_12)]
-    pub _co_cached: *mut _PyCoCached,
-    #[cfg(all(Py_3_12, not(Py_3_13)))]
-    pub _co_instrumentation_version: u64,
-    #[cfg(Py_3_13)]
-    pub _co_instrumentation_version: libc::uintptr_t,
-    #[cfg(Py_3_12)]
-    pub _co_monitoring: *mut _PyCoMonitoringData,
-    pub _co_firsttraceable: c_int,
-    pub co_extra: *mut c_void,
-    pub co_code_adaptive: [c_char; 1],
-}
-
-#[cfg(PyPy)]
-#[repr(C)]
-pub struct PyCodeObject {
-    pub ob_base: PyObject,
-    pub co_name: *mut PyObject,
-    pub co_filename: *mut PyObject,
-    pub co_argcount: c_int,
-    pub co_flags: c_int,
-}
+opaque_struct!(
+    #[doc = "A Python code object.\n"]
+    #[doc = "\n"]
+    #[doc = "`pyo3-ffi` does not expose the contents of this struct, as it has no stability guarantees."]
+    pub PyCodeObject
+);
 
 /* Masks for co_flags */
 pub const CO_OPTIMIZED: c_int = 0x0001;
@@ -249,28 +83,14 @@ pub unsafe fn PyCode_Check(op: *mut PyObject) -> c_int {
     (Py_TYPE(op) == addr_of_mut!(PyCode_Type)) as c_int
 }
 
-#[inline]
-#[cfg(all(not(any(PyPy, GraalPy)), Py_3_10, not(Py_3_11)))]
-pub unsafe fn PyCode_GetNumFree(op: *mut PyCodeObject) -> Py_ssize_t {
-    crate::PyTuple_GET_SIZE((*op).co_freevars)
-}
-
-#[inline]
-#[cfg(all(not(Py_3_10), Py_3_11, not(any(PyPy, GraalPy))))]
-pub unsafe fn PyCode_GetNumFree(op: *mut PyCodeObject) -> c_int {
-    (*op).co_nfreevars
-}
-
 extern "C" {
     #[cfg(PyPy)]
     #[link_name = "PyPyCode_Check"]
     pub fn PyCode_Check(op: *mut PyObject) -> c_int;
-
-    #[cfg(PyPy)]
-    #[link_name = "PyPyCode_GetNumFree"]
-    pub fn PyCode_GetNumFree(op: *mut PyCodeObject) -> Py_ssize_t;
 }
 
+// skipped PyCode_GetNumFree (requires knowledge of code object layout)
+
 extern "C" {
     #[cfg(not(GraalPy))]
     #[cfg_attr(PyPy, link_name = "PyPyCode_New")]
diff --git a/pyo3-ffi/src/cpython/compile.rs b/pyo3-ffi/src/cpython/compile.rs
index 79f06c92003..078b5e0d675 100644
--- a/pyo3-ffi/src/cpython/compile.rs
+++ b/pyo3-ffi/src/cpython/compile.rs
@@ -6,19 +6,21 @@ use crate::pyarena::*;
 use crate::pythonrun::*;
 #[cfg(not(any(PyPy, Py_3_10)))]
 use crate::PyCodeObject;
+use crate::INT_MAX;
 #[cfg(not(any(PyPy, Py_3_10)))]
 use std::os::raw::c_char;
 use std::os::raw::c_int;
 
-// skipped non-limited PyCF_MASK
-// skipped non-limited PyCF_MASK_OBSOLETE
-// skipped non-limited PyCF_SOURCE_IS_UTF8
-// skipped non-limited PyCF_DONT_IMPLY_DEDENT
-// skipped non-limited PyCF_ONLY_AST
-// skipped non-limited PyCF_IGNORE_COOKIE
-// skipped non-limited PyCF_TYPE_COMMENTS
-// skipped non-limited PyCF_ALLOW_TOP_LEVEL_AWAIT
-// skipped non-limited PyCF_COMPILE_MASK
+// skipped PyCF_MASK
+// skipped PyCF_MASK_OBSOLETE
+// skipped PyCF_SOURCE_IS_UTF8
+// skipped PyCF_DONT_IMPLY_DEDENT
+// skipped PyCF_ONLY_AST
+// skipped PyCF_IGNORE_COOKIE
+// skipped PyCF_TYPE_COMMENTS
+// skipped PyCF_ALLOW_TOP_LEVEL_AWAIT
+// skipped PyCF_OPTIMIZED_AST
+// skipped PyCF_COMPILE_MASK
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -28,31 +30,23 @@ pub struct PyCompilerFlags {
     pub cf_feature_version: c_int,
 }
 
-// skipped non-limited _PyCompilerFlags_INIT
+// skipped _PyCompilerFlags_INIT
 
-#[cfg(all(Py_3_12, not(any(Py_3_13, PyPy, GraalPy))))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct _PyCompilerSrcLocation {
-    pub lineno: c_int,
-    pub end_lineno: c_int,
-    pub col_offset: c_int,
-    pub end_col_offset: c_int,
-}
-
-// skipped SRC_LOCATION_FROM_AST
-
-#[cfg(not(any(PyPy, GraalPy, Py_3_13)))]
+// NB this type technically existed in the header until 3.13, when it was
+// moved to the internal CPython headers.
+//
+// We choose not to expose it in the public API past 3.10, as it is
+// not used in the public API past that point.
+#[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct PyFutureFeatures {
     pub ff_features: c_int,
-    #[cfg(not(Py_3_12))]
     pub ff_lineno: c_int,
-    #[cfg(Py_3_12)]
-    pub ff_location: _PyCompilerSrcLocation,
 }
 
+// FIXME: these constants should probably be &CStr, if they are used at all
+
 pub const FUTURE_NESTED_SCOPES: &str = "nested_scopes";
 pub const FUTURE_GENERATORS: &str = "generators";
 pub const FUTURE_DIVISION: &str = "division";
@@ -62,13 +56,12 @@ pub const FUTURE_PRINT_FUNCTION: &str = "print_function";
 pub const FUTURE_UNICODE_LITERALS: &str = "unicode_literals";
 pub const FUTURE_BARRY_AS_BDFL: &str = "barry_as_FLUFL";
 pub const FUTURE_GENERATOR_STOP: &str = "generator_stop";
-// skipped non-limited FUTURE_ANNOTATIONS
+pub const FUTURE_ANNOTATIONS: &str = "annotations";
 
+#[cfg(not(any(PyPy, GraalPy, Py_3_10)))]
 extern "C" {
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyNode_Compile(arg1: *mut _node, arg2: *const c_char) -> *mut PyCodeObject;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyAST_CompileEx(
         _mod: *mut _mod,
         filename: *const c_char,
@@ -77,7 +70,6 @@ extern "C" {
         arena: *mut PyArena,
     ) -> *mut PyCodeObject;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyAST_CompileObject(
         _mod: *mut _mod,
         filename: *mut PyObject,
@@ -86,23 +78,20 @@ extern "C" {
         arena: *mut PyArena,
     ) -> *mut PyCodeObject;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyFuture_FromAST(_mod: *mut _mod, filename: *const c_char) -> *mut PyFutureFeatures;
 
-    #[cfg(not(any(PyPy, Py_3_10)))]
     pub fn PyFuture_FromASTObject(
         _mod: *mut _mod,
         filename: *mut PyObject,
     ) -> *mut PyFutureFeatures;
+}
 
-    // skipped non-limited _Py_Mangle
-    // skipped non-limited PY_INVALID_STACK_EFFECT
+pub const PY_INVALID_STACK_EFFECT: c_int = INT_MAX;
+
+extern "C" {
 
     pub fn PyCompile_OpcodeStackEffect(opcode: c_int, oparg: c_int) -> c_int;
 
     #[cfg(Py_3_8)]
     pub fn PyCompile_OpcodeStackEffectWithJump(opcode: c_int, oparg: c_int, jump: c_int) -> c_int;
-
-    // skipped non-limited _PyASTOptimizeState
-    // skipped non-limited _PyAST_Optimize
 }
diff --git a/pyo3-ffi/src/cpython/critical_section.rs b/pyo3-ffi/src/cpython/critical_section.rs
index 97b2f5e0559..808dba870c6 100644
--- a/pyo3-ffi/src/cpython/critical_section.rs
+++ b/pyo3-ffi/src/cpython/critical_section.rs
@@ -17,10 +17,10 @@ pub struct PyCriticalSection2 {
 }
 
 #[cfg(not(Py_GIL_DISABLED))]
-opaque_struct!(PyCriticalSection);
+opaque_struct!(pub PyCriticalSection);
 
 #[cfg(not(Py_GIL_DISABLED))]
-opaque_struct!(PyCriticalSection2);
+opaque_struct!(pub PyCriticalSection2);
 
 extern "C" {
     pub fn PyCriticalSection_Begin(c: *mut PyCriticalSection, op: *mut PyObject);
diff --git a/pyo3-ffi/src/cpython/descrobject.rs b/pyo3-ffi/src/cpython/descrobject.rs
index 1b5ee466c8e..7cef9bdbf42 100644
--- a/pyo3-ffi/src/cpython/descrobject.rs
+++ b/pyo3-ffi/src/cpython/descrobject.rs
@@ -69,10 +69,7 @@ pub struct PyWrapperDescrObject {
     pub d_wrapped: *mut c_void,
 }
 
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut _PyMethodWrapper_Type: PyTypeObject;
-}
+// skipped _PyMethodWrapper_Type
 
 // skipped non-limited PyDescr_NewWrapper
 // skipped non-limited PyDescr_IsData
diff --git a/pyo3-ffi/src/cpython/dictobject.rs b/pyo3-ffi/src/cpython/dictobject.rs
index 79dcbfdb62e..34b66a9699d 100644
--- a/pyo3-ffi/src/cpython/dictobject.rs
+++ b/pyo3-ffi/src/cpython/dictobject.rs
@@ -2,10 +2,10 @@ use crate::object::*;
 use crate::pyport::Py_ssize_t;
 use std::os::raw::c_int;
 
-opaque_struct!(PyDictKeysObject);
+opaque_struct!(pub PyDictKeysObject);
 
 #[cfg(Py_3_11)]
-opaque_struct!(PyDictValues);
+opaque_struct!(pub PyDictValues);
 
 #[cfg(not(GraalPy))]
 #[repr(C)]
@@ -17,7 +17,10 @@ pub struct PyDictObject {
         Py_3_12,
         deprecated(note = "Deprecated in Python 3.12 and will be removed in the future.")
     )]
+    #[cfg(not(Py_3_14))]
     pub ma_version_tag: u64,
+    #[cfg(Py_3_14)]
+    _ma_watcher_tag: u64,
     pub ma_keys: *mut PyDictKeysObject,
     #[cfg(not(Py_3_11))]
     pub ma_values: *mut *mut PyObject,
diff --git a/pyo3-ffi/src/cpython/frameobject.rs b/pyo3-ffi/src/cpython/frameobject.rs
index e9b9c183f37..993e93c838b 100644
--- a/pyo3-ffi/src/cpython/frameobject.rs
+++ b/pyo3-ffi/src/cpython/frameobject.rs
@@ -53,7 +53,7 @@ pub struct PyFrameObject {
 }
 
 #[cfg(any(PyPy, GraalPy, Py_3_11))]
-opaque_struct!(PyFrameObject);
+opaque_struct!(pub PyFrameObject);
 
 // skipped _PyFrame_IsRunnable
 // skipped _PyFrame_IsExecuting
diff --git a/pyo3-ffi/src/cpython/funcobject.rs b/pyo3-ffi/src/cpython/funcobject.rs
index 25de30d57f7..cd2052de174 100644
--- a/pyo3-ffi/src/cpython/funcobject.rs
+++ b/pyo3-ffi/src/cpython/funcobject.rs
@@ -41,6 +41,8 @@ pub struct PyFunctionObject {
     pub func_weakreflist: *mut PyObject,
     pub func_module: *mut PyObject,
     pub func_annotations: *mut PyObject,
+    #[cfg(Py_3_14)]
+    pub func_annotate: *mut PyObject,
     #[cfg(Py_3_12)]
     pub func_typeparams: *mut PyObject,
     pub vectorcall: Option<crate::vectorcallfunc>,
diff --git a/pyo3-ffi/src/cpython/genobject.rs b/pyo3-ffi/src/cpython/genobject.rs
index c9d419e3782..92f14d59e4b 100644
--- a/pyo3-ffi/src/cpython/genobject.rs
+++ b/pyo3-ffi/src/cpython/genobject.rs
@@ -1,13 +1,11 @@
 use crate::object::*;
 use crate::PyFrameObject;
-#[cfg(not(any(PyPy, GraalPy)))]
-use crate::_PyErr_StackItem;
-#[cfg(all(Py_3_11, not(any(PyPy, GraalPy))))]
+#[cfg(all(Py_3_11, not(any(PyPy, GraalPy, Py_3_14))))]
 use std::os::raw::c_char;
 use std::os::raw::c_int;
 use std::ptr::addr_of_mut;
 
-#[cfg(not(any(PyPy, GraalPy)))]
+#[cfg(not(any(PyPy, GraalPy, Py_3_14)))]
 #[repr(C)]
 pub struct PyGenObject {
     pub ob_base: PyObject,
@@ -20,7 +18,7 @@ pub struct PyGenObject {
     pub gi_weakreflist: *mut PyObject,
     pub gi_name: *mut PyObject,
     pub gi_qualname: *mut PyObject,
-    pub gi_exc_state: _PyErr_StackItem,
+    pub gi_exc_state: crate::cpython::pystate::_PyErr_StackItem,
     #[cfg(Py_3_11)]
     pub gi_origin_or_finalizer: *mut PyObject,
     #[cfg(Py_3_11)]
@@ -35,6 +33,9 @@ pub struct PyGenObject {
     pub gi_iframe: [*mut PyObject; 1],
 }
 
+#[cfg(all(Py_3_14, not(any(PyPy, GraalPy))))]
+opaque_struct!(pub PyGenObject);
+
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     pub static mut PyGen_Type: PyTypeObject;
@@ -67,9 +68,10 @@ extern "C" {
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     pub static mut PyCoro_Type: PyTypeObject;
-    pub static mut _PyCoroWrapper_Type: PyTypeObject;
 }
 
+// skipped _PyCoroWrapper_Type
+
 #[inline]
 pub unsafe fn PyCoro_CheckExact(op: *mut PyObject) -> c_int {
     PyObject_TypeCheck(op, addr_of_mut!(PyCoro_Type))
diff --git a/pyo3-ffi/src/cpython/import.rs b/pyo3-ffi/src/cpython/import.rs
index 697d68a419c..c8ef5ab487e 100644
--- a/pyo3-ffi/src/cpython/import.rs
+++ b/pyo3-ffi/src/cpython/import.rs
@@ -65,10 +65,8 @@ pub struct _frozen {
 extern "C" {
     #[cfg(not(PyPy))]
     pub static mut PyImport_FrozenModules: *const _frozen;
-    #[cfg(all(not(PyPy), Py_3_11))]
-    pub static mut _PyImport_FrozenBootstrap: *const _frozen;
-    #[cfg(all(not(PyPy), Py_3_11))]
-    pub static mut _PyImport_FrozenStdlib: *const _frozen;
-    #[cfg(all(not(PyPy), Py_3_11))]
-    pub static mut _PyImport_FrozenTest: *const _frozen;
 }
+
+// skipped _PyImport_FrozenBootstrap
+// skipped _PyImport_FrozenStdlib
+// skipped _PyImport_FrozenTest
diff --git a/pyo3-ffi/src/cpython/initconfig.rs b/pyo3-ffi/src/cpython/initconfig.rs
index 321d200e141..076981f1485 100644
--- a/pyo3-ffi/src/cpython/initconfig.rs
+++ b/pyo3-ffi/src/cpython/initconfig.rs
@@ -93,6 +93,8 @@ pub struct PyConfig {
     pub tracemalloc: c_int,
     #[cfg(Py_3_12)]
     pub perf_profiling: c_int,
+    #[cfg(Py_3_14)]
+    pub remote_debug: c_int,
     pub import_time: c_int,
     #[cfg(Py_3_11)]
     pub code_debug_ranges: c_int,
@@ -141,10 +143,18 @@ pub struct PyConfig {
     pub safe_path: c_int,
     #[cfg(Py_3_12)]
     pub int_max_str_digits: c_int,
+    #[cfg(Py_3_14)]
+    pub thread_inherit_context: c_int,
+    #[cfg(Py_3_14)]
+    pub context_aware_warnings: c_int,
+    #[cfg(all(Py_3_14, target_os = "macos"))]
+    pub use_system_logger: c_int,
     #[cfg(Py_3_13)]
     pub cpu_count: c_int,
     #[cfg(Py_GIL_DISABLED)]
     pub enable_gil: c_int,
+    #[cfg(all(Py_3_14, Py_GIL_DISABLED))]
+    pub tlbc_enabled: c_int,
     pub pathconfig_warnings: c_int,
     #[cfg(Py_3_10)]
     pub program_name: *mut wchar_t,
diff --git a/pyo3-ffi/src/cpython/mod.rs b/pyo3-ffi/src/cpython/mod.rs
index f09d51d0e4e..adaf8bc8861 100644
--- a/pyo3-ffi/src/cpython/mod.rs
+++ b/pyo3-ffi/src/cpython/mod.rs
@@ -38,6 +38,7 @@ pub(crate) mod pythonrun;
 // skipped sysmodule.h
 pub(crate) mod floatobject;
 pub(crate) mod pyframe;
+pub(crate) mod pyhash;
 pub(crate) mod tupleobject;
 pub(crate) mod unicodeobject;
 pub(crate) mod weakrefobject;
@@ -73,6 +74,8 @@ pub use self::pydebug::*;
 pub use self::pyerrors::*;
 #[cfg(all(Py_3_11, not(PyPy)))]
 pub use self::pyframe::*;
+#[cfg(any(not(PyPy), Py_3_13))]
+pub use self::pyhash::*;
 #[cfg(all(Py_3_8, not(PyPy)))]
 pub use self::pylifecycle::*;
 pub use self::pymem::*;
diff --git a/pyo3-ffi/src/cpython/object.rs b/pyo3-ffi/src/cpython/object.rs
index 4e6932da789..26ef784dde1 100644
--- a/pyo3-ffi/src/cpython/object.rs
+++ b/pyo3-ffi/src/cpython/object.rs
@@ -312,8 +312,12 @@ pub struct PyHeapTypeObject {
     pub ht_module: *mut object::PyObject,
     #[cfg(all(Py_3_11, not(PyPy)))]
     _ht_tpname: *mut c_char,
+    #[cfg(Py_3_14)]
+    pub ht_token: *mut c_void,
     #[cfg(all(Py_3_11, not(PyPy)))]
     _spec_cache: _specialization_cache,
+    #[cfg(all(Py_GIL_DISABLED, Py_3_14))]
+    pub unique_id: Py_ssize_t,
 }
 
 impl Default for PyHeapTypeObject {
diff --git a/pyo3-ffi/src/cpython/pyerrors.rs b/pyo3-ffi/src/cpython/pyerrors.rs
index c6e10e5f07b..c9831669ac7 100644
--- a/pyo3-ffi/src/cpython/pyerrors.rs
+++ b/pyo3-ffi/src/cpython/pyerrors.rs
@@ -46,6 +46,8 @@ pub struct PySyntaxErrorObject {
     pub end_offset: *mut PyObject,
     pub text: *mut PyObject,
     pub print_file_and_line: *mut PyObject,
+    #[cfg(Py_3_14)]
+    pub metadata: *mut PyObject,
 }
 
 #[cfg(not(any(PyPy, GraalPy)))]
diff --git a/pyo3-ffi/src/cpython/pyframe.rs b/pyo3-ffi/src/cpython/pyframe.rs
index 5e1e16a7d08..f0c38be47be 100644
--- a/pyo3-ffi/src/cpython/pyframe.rs
+++ b/pyo3-ffi/src/cpython/pyframe.rs
@@ -1,2 +1,3 @@
+// NB used in `_PyEval_EvalFrameDefault`, maybe we remove this too.
 #[cfg(all(Py_3_11, not(PyPy)))]
-opaque_struct!(_PyInterpreterFrame);
+opaque_struct!(pub _PyInterpreterFrame);
diff --git a/pyo3-ffi/src/cpython/pyhash.rs b/pyo3-ffi/src/cpython/pyhash.rs
new file mode 100644
index 00000000000..b746018a38a
--- /dev/null
+++ b/pyo3-ffi/src/cpython/pyhash.rs
@@ -0,0 +1,38 @@
+#[cfg(Py_3_14)]
+use crate::Py_ssize_t;
+#[cfg(Py_3_13)]
+use crate::{PyObject, Py_hash_t};
+#[cfg(any(Py_3_13, not(PyPy)))]
+use std::os::raw::c_void;
+#[cfg(not(PyPy))]
+use std::os::raw::{c_char, c_int};
+
+#[cfg(not(PyPy))]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PyHash_FuncDef {
+    pub hash:
+        Option<extern "C" fn(arg1: *const c_void, arg2: crate::Py_ssize_t) -> crate::Py_hash_t>,
+    pub name: *const c_char,
+    pub hash_bits: c_int,
+    pub seed_bits: c_int,
+}
+
+#[cfg(not(PyPy))]
+impl Default for PyHash_FuncDef {
+    #[inline]
+    fn default() -> Self {
+        unsafe { std::mem::zeroed() }
+    }
+}
+
+extern "C" {
+    #[cfg(not(PyPy))]
+    pub fn PyHash_GetFuncDef() -> *mut PyHash_FuncDef;
+    #[cfg(Py_3_13)]
+    pub fn Py_HashPointer(ptr: *const c_void) -> Py_hash_t;
+    #[cfg(Py_3_13)]
+    pub fn PyObject_GenericHash(obj: *mut PyObject) -> Py_hash_t;
+    #[cfg(Py_3_14)]
+    pub fn Py_HashBuffer(ptr: *const c_void, len: Py_ssize_t) -> Py_hash_t;
+}
diff --git a/pyo3-ffi/src/cpython/pystate.rs b/pyo3-ffi/src/cpython/pystate.rs
index 650cd6a1f7f..b8f6fd667b7 100644
--- a/pyo3-ffi/src/cpython/pystate.rs
+++ b/pyo3-ffi/src/cpython/pystate.rs
@@ -27,16 +27,18 @@ pub const PyTrace_OPCODE: c_int = 7;
 // skipped PyTraceInfo
 // skipped CFrame
 
+/// Private structure used inline in `PyGenObject`
 #[cfg(not(PyPy))]
 #[repr(C)]
 #[derive(Clone, Copy)]
+#[doc(hidden)] // TODO should be able to make pub(crate) after MSRV 1.74
 pub struct _PyErr_StackItem {
     #[cfg(not(Py_3_11))]
-    pub exc_type: *mut PyObject,
-    pub exc_value: *mut PyObject,
+    exc_type: *mut PyObject,
+    exc_value: *mut PyObject,
     #[cfg(not(Py_3_11))]
-    pub exc_traceback: *mut PyObject,
-    pub previous_item: *mut _PyErr_StackItem,
+    exc_traceback: *mut PyObject,
+    previous_item: *mut _PyErr_StackItem,
 }
 
 // skipped _PyStackChunk
diff --git a/pyo3-ffi/src/cpython/tupleobject.rs b/pyo3-ffi/src/cpython/tupleobject.rs
index 9616d4372cc..dc1bf8e40d0 100644
--- a/pyo3-ffi/src/cpython/tupleobject.rs
+++ b/pyo3-ffi/src/cpython/tupleobject.rs
@@ -1,10 +1,14 @@
 use crate::object::*;
+#[cfg(Py_3_14)]
+use crate::pyport::Py_hash_t;
 #[cfg(not(PyPy))]
 use crate::pyport::Py_ssize_t;
 
 #[repr(C)]
 pub struct PyTupleObject {
     pub ob_base: PyVarObject,
+    #[cfg(Py_3_14)]
+    pub ob_hash: Py_hash_t,
     pub ob_item: [*mut PyObject; 1],
 }
 
diff --git a/pyo3-ffi/src/cpython/unicodeobject.rs b/pyo3-ffi/src/cpython/unicodeobject.rs
index 3527a5aeadb..452c82e4c4b 100644
--- a/pyo3-ffi/src/cpython/unicodeobject.rs
+++ b/pyo3-ffi/src/cpython/unicodeobject.rs
@@ -31,11 +31,13 @@ use std::os::raw::{c_char, c_int, c_uint, c_void};
 // skipped Py_UNICODE_LOW_SURROGATE
 
 // generated by bindgen v0.63.0 (with small adaptations)
+#[cfg(not(Py_3_14))]
 #[repr(C)]
 struct BitfieldUnit<Storage> {
     storage: Storage,
 }
 
+#[cfg(not(Py_3_14))]
 impl<Storage> BitfieldUnit<Storage> {
     #[inline]
     pub const fn new(storage: Storage) -> Self {
@@ -43,7 +45,7 @@ impl<Storage> BitfieldUnit<Storage> {
     }
 }
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 impl<Storage> BitfieldUnit<Storage>
 where
     Storage: AsRef<[u8]> + AsMut<[u8]>,
@@ -117,27 +119,33 @@ where
     }
 }
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_INTERNED_INDEX: usize = 0;
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_INTERNED_WIDTH: u8 = 2;
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_KIND_INDEX: usize = STATE_INTERNED_WIDTH as usize;
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_KIND_WIDTH: u8 = 3;
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_COMPACT_INDEX: usize = (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH) as usize;
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_COMPACT_WIDTH: u8 = 1;
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_ASCII_INDEX: usize =
     (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH + STATE_COMPACT_WIDTH) as usize;
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 const STATE_ASCII_WIDTH: u8 = 1;
 
+#[cfg(all(not(any(GraalPy, Py_3_14)), Py_3_12))]
+const STATE_STATICALLY_ALLOCATED_INDEX: usize =
+    (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH + STATE_COMPACT_WIDTH + STATE_ASCII_WIDTH) as usize;
+#[cfg(all(not(any(GraalPy, Py_3_14)), Py_3_12))]
+const STATE_STATICALLY_ALLOCATED_WIDTH: u8 = 1;
+
 #[cfg(not(any(Py_3_12, GraalPy)))]
 const STATE_READY_INDEX: usize =
     (STATE_INTERNED_WIDTH + STATE_KIND_WIDTH + STATE_COMPACT_WIDTH + STATE_ASCII_WIDTH) as usize;
@@ -153,15 +161,15 @@ const STATE_READY_WIDTH: u8 = 1;
 ///
 /// Memory layout of C bitfields is implementation defined, so these functions are still
 /// unsafe. Users must verify that they work as expected on the architectures they target.
+#[cfg(not(Py_3_14))]
 #[repr(C)]
-#[repr(align(4))]
 struct PyASCIIObjectState {
     bitfield_align: [u8; 0],
     bitfield: BitfieldUnit<[u8; 4usize]>,
 }
 
 // c_uint and u32 are not necessarily the same type on all targets / architectures
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[allow(clippy::useless_transmute)]
 impl PyASCIIObjectState {
     #[inline]
@@ -215,6 +223,26 @@ impl PyASCIIObjectState {
             .set(STATE_ASCII_INDEX, STATE_ASCII_WIDTH, val as u64)
     }
 
+    #[cfg(Py_3_12)]
+    #[inline]
+    unsafe fn statically_allocated(&self) -> c_uint {
+        std::mem::transmute(self.bitfield.get(
+            STATE_STATICALLY_ALLOCATED_INDEX,
+            STATE_STATICALLY_ALLOCATED_WIDTH,
+        ) as u32)
+    }
+
+    #[cfg(Py_3_12)]
+    #[inline]
+    unsafe fn set_statically_allocated(&mut self, val: c_uint) {
+        let val: u32 = std::mem::transmute(val);
+        self.bitfield.set(
+            STATE_STATICALLY_ALLOCATED_INDEX,
+            STATE_STATICALLY_ALLOCATED_WIDTH,
+            val as u64,
+        )
+    }
+
     #[cfg(not(Py_3_12))]
     #[inline]
     unsafe fn ready(&self) -> c_uint {
@@ -230,6 +258,7 @@ impl PyASCIIObjectState {
     }
 }
 
+#[cfg(not(Py_3_14))]
 impl From<u32> for PyASCIIObjectState {
     #[inline]
     fn from(value: u32) -> Self {
@@ -240,6 +269,7 @@ impl From<u32> for PyASCIIObjectState {
     }
 }
 
+#[cfg(not(Py_3_14))]
 impl From<PyASCIIObjectState> for u32 {
     #[inline]
     fn from(value: PyASCIIObjectState) -> Self {
@@ -258,19 +288,29 @@ pub struct PyASCIIObject {
     /// Rust doesn't expose bitfields. So we have accessor functions for
     /// retrieving values.
     ///
+    /// Before 3.12:
     /// unsigned int interned:2; // SSTATE_* constants.
     /// unsigned int kind:3;     // PyUnicode_*_KIND constants.
     /// unsigned int compact:1;
     /// unsigned int ascii:1;
     /// unsigned int ready:1;
     /// unsigned int :24;
+    ///
+    /// 3.12, and 3.13
+    /// unsigned int interned:2; // SSTATE_* constants.
+    /// unsigned int kind:3;     // PyUnicode_*_KIND constants.
+    /// unsigned int compact:1;
+    /// unsigned int ascii:1;
+    /// unsigned int statically_allocated:1;
+    /// unsigned int :24;
+    /// on 3.14 and higher PyO3 doesn't access the internal state
     pub state: u32,
     #[cfg(not(Py_3_12))]
     pub wstr: *mut wchar_t,
 }
 
 /// Interacting with the bitfield is not actually well-defined, so we mark these APIs unsafe.
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 impl PyASCIIObject {
     #[cfg_attr(not(Py_3_12), allow(rustdoc::broken_intra_doc_links))] // SSTATE_INTERNED_IMMORTAL_STATIC requires 3.12
     /// Get the `interned` field of the [`PyASCIIObject`] state bitfield.
@@ -347,6 +387,7 @@ impl PyASCIIObject {
     ///
     /// Calling this function with an argument that is neither `0` nor `1` is invalid.
     #[inline]
+    #[cfg(not(all(Py_3_14, Py_GIL_DISABLED)))]
     pub unsafe fn set_ascii(&mut self, val: c_uint) {
         let mut state = PyASCIIObjectState::from(self.state);
         state.set_ascii(val);
@@ -372,6 +413,26 @@ impl PyASCIIObject {
         state.set_ready(val);
         self.state = u32::from(state);
     }
+
+    /// Get the `statically_allocated` field of the [`PyASCIIObject`] state bitfield.
+    ///
+    /// Returns either `0` or `1`.
+    #[inline]
+    #[cfg(Py_3_12)]
+    pub unsafe fn statically_allocated(&self) -> c_uint {
+        PyASCIIObjectState::from(self.state).statically_allocated()
+    }
+
+    /// Set the `statically_allocated` flag of the [`PyASCIIObject`] state bitfield.
+    ///
+    /// Calling this function with an argument that is neither `0` nor `1` is invalid.
+    #[inline]
+    #[cfg(Py_3_12)]
+    pub unsafe fn set_statically_allocated(&mut self, val: c_uint) {
+        let mut state = PyASCIIObjectState::from(self.state);
+        state.set_statically_allocated(val);
+        self.state = u32::from(state);
+    }
 }
 
 #[repr(C)]
@@ -413,7 +474,7 @@ pub const SSTATE_INTERNED_IMMORTAL: c_uint = 2;
 #[cfg(Py_3_12)]
 pub const SSTATE_INTERNED_IMMORTAL_STATIC: c_uint = 3;
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_ASCII(op: *mut PyObject) -> c_uint {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -423,13 +484,13 @@ pub unsafe fn PyUnicode_IS_ASCII(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).ascii()
 }
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_COMPACT(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).compact()
 }
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_IS_COMPACT_ASCII(op: *mut PyObject) -> c_uint {
     ((*(op as *mut PyASCIIObject)).ascii() != 0 && PyUnicode_IS_COMPACT(op) != 0).into()
@@ -461,7 +522,13 @@ pub unsafe fn PyUnicode_4BYTE_DATA(op: *mut PyObject) -> *mut Py_UCS4 {
     PyUnicode_DATA(op) as *mut Py_UCS4
 }
 
-#[cfg(not(GraalPy))]
+#[cfg(all(not(GraalPy), Py_3_14))]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyUnicode_KIND")]
+    pub fn PyUnicode_KIND(op: *mut PyObject) -> c_uint;
+}
+
+#[cfg(all(not(GraalPy), not(Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_KIND(op: *mut PyObject) -> c_uint {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -471,7 +538,7 @@ pub unsafe fn PyUnicode_KIND(op: *mut PyObject) -> c_uint {
     (*(op as *mut PyASCIIObject)).kind()
 }
 
-#[cfg(not(GraalPy))]
+#[cfg(not(any(GraalPy, Py_3_14)))]
 #[inline]
 pub unsafe fn _PyUnicode_COMPACT_DATA(op: *mut PyObject) -> *mut c_void {
     if PyUnicode_IS_ASCII(op) != 0 {
@@ -489,7 +556,7 @@ pub unsafe fn _PyUnicode_NONCOMPACT_DATA(op: *mut PyObject) -> *mut c_void {
     (*(op as *mut PyUnicodeObject)).data.any
 }
 
-#[cfg(not(any(GraalPy, PyPy)))]
+#[cfg(not(any(GraalPy, PyPy, Py_3_14)))]
 #[inline]
 pub unsafe fn PyUnicode_DATA(op: *mut PyObject) -> *mut c_void {
     debug_assert!(crate::PyUnicode_Check(op) != 0);
@@ -501,6 +568,13 @@ pub unsafe fn PyUnicode_DATA(op: *mut PyObject) -> *mut c_void {
     }
 }
 
+#[cfg(Py_3_14)]
+#[cfg(all(not(GraalPy), Py_3_14))]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPyUnicode_DATA")]
+    pub fn PyUnicode_DATA(op: *mut PyObject) -> *mut c_void;
+}
+
 // skipped PyUnicode_WRITE
 // skipped PyUnicode_READ
 // skipped PyUnicode_READ_CHAR
diff --git a/pyo3-ffi/src/cpython/weakrefobject.rs b/pyo3-ffi/src/cpython/weakrefobject.rs
index 88bb501bcc5..1c50c7a759f 100644
--- a/pyo3-ffi/src/cpython/weakrefobject.rs
+++ b/pyo3-ffi/src/cpython/weakrefobject.rs
@@ -1,3 +1,4 @@
+// NB publicly re-exported in `src/weakrefobject.rs`
 #[cfg(not(any(PyPy, GraalPy)))]
 pub struct _PyWeakReference {
     pub ob_base: crate::PyObject,
diff --git a/pyo3-ffi/src/datetime.rs b/pyo3-ffi/src/datetime.rs
index 7f2d7958364..4db1bdd16d1 100644
--- a/pyo3-ffi/src/datetime.rs
+++ b/pyo3-ffi/src/datetime.rs
@@ -487,7 +487,9 @@ extern "C" {
     pub fn PyDateTime_DATE_GET_MICROSECOND(o: *mut PyObject) -> c_int;
     #[link_name = "PyPyDateTime_GET_FOLD"]
     pub fn PyDateTime_DATE_GET_FOLD(o: *mut PyObject) -> c_int;
-    // skipped PyDateTime_DATE_GET_TZINFO (not in PyPy)
+    #[link_name = "PyPyDateTime_DATE_GET_TZINFO"]
+    #[cfg(Py_3_10)]
+    pub fn PyDateTime_DATE_GET_TZINFO(o: *mut PyObject) -> *mut PyObject;
 
     #[link_name = "PyPyDateTime_TIME_GET_HOUR"]
     pub fn PyDateTime_TIME_GET_HOUR(o: *mut PyObject) -> c_int;
@@ -499,7 +501,9 @@ extern "C" {
     pub fn PyDateTime_TIME_GET_MICROSECOND(o: *mut PyObject) -> c_int;
     #[link_name = "PyPyDateTime_TIME_GET_FOLD"]
     pub fn PyDateTime_TIME_GET_FOLD(o: *mut PyObject) -> c_int;
-    // skipped PyDateTime_TIME_GET_TZINFO (not in PyPy)
+    #[link_name = "PyPyDateTime_TIME_GET_TZINFO"]
+    #[cfg(Py_3_10)]
+    pub fn PyDateTime_TIME_GET_TZINFO(o: *mut PyObject) -> *mut PyObject;
 
     #[link_name = "PyPyDateTime_DELTA_GET_DAYS"]
     pub fn PyDateTime_DELTA_GET_DAYS(o: *mut PyObject) -> c_int;
diff --git a/pyo3-ffi/src/dictobject.rs b/pyo3-ffi/src/dictobject.rs
index 710be80243f..e609352ac1b 100644
--- a/pyo3-ffi/src/dictobject.rs
+++ b/pyo3-ffi/src/dictobject.rs
@@ -118,4 +118,4 @@ extern "C" {
 
 #[cfg(any(PyPy, GraalPy, Py_LIMITED_API))]
 // TODO: remove (see https://github.com/PyO3/pyo3/pull/1341#issuecomment-751515985)
-opaque_struct!(PyDictObject);
+opaque_struct!(pub PyDictObject);
diff --git a/pyo3-ffi/src/floatobject.rs b/pyo3-ffi/src/floatobject.rs
index 65fc1d4c316..4e1d6476f58 100644
--- a/pyo3-ffi/src/floatobject.rs
+++ b/pyo3-ffi/src/floatobject.rs
@@ -4,7 +4,7 @@ use std::ptr::addr_of_mut;
 
 #[cfg(Py_LIMITED_API)]
 // TODO: remove (see https://github.com/PyO3/pyo3/pull/1341#issuecomment-751515985)
-opaque_struct!(PyFloatObject);
+opaque_struct!(pub PyFloatObject);
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
diff --git a/pyo3-ffi/src/lib.rs b/pyo3-ffi/src/lib.rs
index aba8866b266..f78c918a8c5 100644
--- a/pyo3-ffi/src/lib.rs
+++ b/pyo3-ffi/src/lib.rs
@@ -341,9 +341,10 @@
 // model opaque types:
 // https://doc.rust-lang.org/nomicon/ffi.html#representing-opaque-structs
 macro_rules! opaque_struct {
-    ($name:ident) => {
+    ($(#[$attrs:meta])* $pub:vis $name:ident) => {
+        $(#[$attrs])*
         #[repr(C)]
-        pub struct $name([u8; 0]);
+        $pub struct $name([u8; 0]);
     };
 }
 
@@ -447,6 +448,7 @@ pub use self::pystate::*;
 pub use self::pystrtod::*;
 pub use self::pythonrun::*;
 pub use self::rangeobject::*;
+pub use self::refcount::*;
 pub use self::setobject::*;
 pub use self::sliceobject::*;
 pub use self::structseq::*;
@@ -539,6 +541,7 @@ mod pystrtod;
 // skipped pythread.h
 // skipped pytime.h
 mod rangeobject;
+mod refcount;
 mod setobject;
 mod sliceobject;
 mod structseq;
diff --git a/pyo3-ffi/src/longobject.rs b/pyo3-ffi/src/longobject.rs
index 68b4ecba540..eca0af3d0a5 100644
--- a/pyo3-ffi/src/longobject.rs
+++ b/pyo3-ffi/src/longobject.rs
@@ -4,7 +4,7 @@ use libc::size_t;
 use std::os::raw::{c_char, c_double, c_int, c_long, c_longlong, c_ulong, c_ulonglong, c_void};
 use std::ptr::addr_of_mut;
 
-opaque_struct!(PyLongObject);
+opaque_struct!(pub PyLongObject);
 
 #[inline]
 pub unsafe fn PyLong_Check(op: *mut PyObject) -> c_int {
diff --git a/pyo3-ffi/src/memoryobject.rs b/pyo3-ffi/src/memoryobject.rs
index b7ef9e2ef1d..4e1e50c6c82 100644
--- a/pyo3-ffi/src/memoryobject.rs
+++ b/pyo3-ffi/src/memoryobject.rs
@@ -3,11 +3,10 @@ use crate::pyport::Py_ssize_t;
 use std::os::raw::{c_char, c_int};
 use std::ptr::addr_of_mut;
 
+// skipped _PyManagedBuffer_Type
+
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
-    #[cfg(not(Py_LIMITED_API))]
-    pub static mut _PyManagedBuffer_Type: PyTypeObject;
-
     #[cfg_attr(PyPy, link_name = "PyPyMemoryView_Type")]
     pub static mut PyMemoryView_Type: PyTypeObject;
 }
diff --git a/pyo3-ffi/src/modsupport.rs b/pyo3-ffi/src/modsupport.rs
index 4a18d30f97c..56a68fe2613 100644
--- a/pyo3-ffi/src/modsupport.rs
+++ b/pyo3-ffi/src/modsupport.rs
@@ -36,6 +36,8 @@ extern "C" {
     pub fn Py_BuildValue(arg1: *const c_char, ...) -> *mut PyObject;
     // skipped Py_VaBuildValue
 
+    #[cfg(Py_3_13)]
+    pub fn PyModule_Add(module: *mut PyObject, name: *const c_char, value: *mut PyObject) -> c_int;
     #[cfg(Py_3_10)]
     #[cfg_attr(PyPy, link_name = "PyPyModule_AddObjectRef")]
     pub fn PyModule_AddObjectRef(
diff --git a/pyo3-ffi/src/object.rs b/pyo3-ffi/src/object.rs
index 087cd32920c..c4c5abc361c 100644
--- a/pyo3-ffi/src/object.rs
+++ b/pyo3-ffi/src/object.rs
@@ -1,5 +1,7 @@
 use crate::pyport::{Py_hash_t, Py_ssize_t};
 #[cfg(Py_GIL_DISABLED)]
+use crate::refcount;
+#[cfg(Py_GIL_DISABLED)]
 use crate::PyMutex;
 #[cfg(Py_GIL_DISABLED)]
 use std::marker::PhantomPinned;
@@ -7,81 +9,50 @@ use std::mem;
 use std::os::raw::{c_char, c_int, c_uint, c_ulong, c_void};
 use std::ptr;
 #[cfg(Py_GIL_DISABLED)]
-use std::sync::atomic::{AtomicIsize, AtomicU32, AtomicU8, Ordering::Relaxed};
+use std::sync::atomic::{AtomicIsize, AtomicU32, AtomicU8};
 
 #[cfg(Py_LIMITED_API)]
-opaque_struct!(PyTypeObject);
+opaque_struct!(pub PyTypeObject);
 
 #[cfg(not(Py_LIMITED_API))]
 pub use crate::cpython::object::PyTypeObject;
 
-#[cfg(Py_3_12)]
-const _Py_IMMORTAL_REFCNT: Py_ssize_t = {
-    if cfg!(target_pointer_width = "64") {
-        c_uint::MAX as Py_ssize_t
-    } else {
-        // for 32-bit systems, use the lower 30 bits (see comment in CPython's object.h)
-        (c_uint::MAX >> 2) as Py_ssize_t
-    }
-};
-
-#[cfg(Py_GIL_DISABLED)]
-const _Py_IMMORTAL_REFCNT_LOCAL: u32 = u32::MAX;
-
-#[allow(clippy::declare_interior_mutable_const)]
-pub const PyObject_HEAD_INIT: PyObject = PyObject {
-    #[cfg(py_sys_config = "Py_TRACE_REFS")]
-    _ob_next: std::ptr::null_mut(),
-    #[cfg(py_sys_config = "Py_TRACE_REFS")]
-    _ob_prev: std::ptr::null_mut(),
-    #[cfg(Py_GIL_DISABLED)]
-    ob_tid: 0,
-    #[cfg(Py_GIL_DISABLED)]
-    _padding: 0,
-    #[cfg(Py_GIL_DISABLED)]
-    ob_mutex: PyMutex {
-        _bits: AtomicU8::new(0),
-        _pin: PhantomPinned,
-    },
-    #[cfg(Py_GIL_DISABLED)]
-    ob_gc_bits: 0,
-    #[cfg(Py_GIL_DISABLED)]
-    ob_ref_local: AtomicU32::new(_Py_IMMORTAL_REFCNT_LOCAL),
-    #[cfg(Py_GIL_DISABLED)]
-    ob_ref_shared: AtomicIsize::new(0),
-    #[cfg(all(not(Py_GIL_DISABLED), Py_3_12))]
-    ob_refcnt: PyObjectObRefcnt { ob_refcnt: 1 },
-    #[cfg(not(Py_3_12))]
-    ob_refcnt: 1,
-    #[cfg(PyPy)]
-    ob_pypy_link: 0,
-    ob_type: std::ptr::null_mut(),
-};
-
-// skipped PyObject_VAR_HEAD
-// skipped Py_INVALID_SIZE
-
-// skipped private _Py_UNOWNED_TID
+// skip PyObject_HEAD
 
-#[cfg(Py_GIL_DISABLED)]
-const _Py_REF_SHARED_SHIFT: isize = 2;
-// skipped private _Py_REF_SHARED_FLAG_MASK
-
-// skipped private _Py_REF_SHARED_INIT
-// skipped private _Py_REF_MAYBE_WEAKREF
-// skipped private _Py_REF_QUEUED
-// skipped private _Py_REF_MERGED
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED), target_endian = "big"))]
+/// This struct is anonymous in CPython, so the name was given by PyO3 because
+/// Rust structs need a name.
+pub struct PyObjectObFlagsAndRefcnt {
+    pub ob_flags: u16,
+    pub ob_overflow: u16,
+    pub ob_refcnt: u32,
+}
 
-// skipped private _Py_REF_SHARED
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED), target_endian = "little"))]
+/// This struct is anonymous in CPython, so the name was given by PyO3 because
+/// Rust structs need a name.
+pub struct PyObjectObFlagsAndRefcnt {
+    pub ob_refcnt: u32,
+    pub ob_overflow: u16,
+    pub ob_flags: u16,
+}
 
 #[repr(C)]
 #[derive(Copy, Clone)]
 #[cfg(all(Py_3_12, not(Py_GIL_DISABLED)))]
 /// This union is anonymous in CPython, so the name was given by PyO3 because
-/// Rust unions need a name.
+/// Rust union need a name.
 pub union PyObjectObRefcnt {
+    #[cfg(all(target_pointer_width = "64", Py_3_14))]
+    pub ob_refcnt_full: crate::PY_INT64_T,
+    #[cfg(Py_3_14)]
+    pub refcnt_and_flags: PyObjectObFlagsAndRefcnt,
     pub ob_refcnt: Py_ssize_t,
-    #[cfg(target_pointer_width = "64")]
+    #[cfg(all(target_pointer_width = "64", not(Py_3_14)))]
     pub ob_refcnt_split: [crate::PY_UINT32_T; 2],
 }
 
@@ -95,6 +66,9 @@ impl std::fmt::Debug for PyObjectObRefcnt {
 #[cfg(all(not(Py_3_12), not(Py_GIL_DISABLED)))]
 pub type PyObjectObRefcnt = Py_ssize_t;
 
+// PyObject_HEAD_INIT comes before the PyObject definition in object.h
+// but we put it after PyObject because HEAD_INIT uses PyObject
+
 #[repr(C)]
 #[derive(Debug)]
 pub struct PyObject {
@@ -104,8 +78,10 @@ pub struct PyObject {
     pub _ob_prev: *mut PyObject,
     #[cfg(Py_GIL_DISABLED)]
     pub ob_tid: libc::uintptr_t,
-    #[cfg(Py_GIL_DISABLED)]
+    #[cfg(all(Py_GIL_DISABLED, not(Py_3_14)))]
     pub _padding: u16,
+    #[cfg(all(Py_GIL_DISABLED, Py_3_14))]
+    pub ob_flags: u16,
     #[cfg(Py_GIL_DISABLED)]
     pub ob_mutex: PyMutex, // per-object lock
     #[cfg(Py_GIL_DISABLED)]
@@ -121,7 +97,41 @@ pub struct PyObject {
     pub ob_type: *mut PyTypeObject,
 }
 
-// skipped private _PyObject_CAST
+#[allow(clippy::declare_interior_mutable_const)]
+pub const PyObject_HEAD_INIT: PyObject = PyObject {
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
+    _ob_next: std::ptr::null_mut(),
+    #[cfg(py_sys_config = "Py_TRACE_REFS")]
+    _ob_prev: std::ptr::null_mut(),
+    #[cfg(Py_GIL_DISABLED)]
+    ob_tid: 0,
+    #[cfg(all(Py_GIL_DISABLED, Py_3_14))]
+    ob_flags: 0,
+    #[cfg(all(Py_GIL_DISABLED, not(Py_3_14)))]
+    _padding: 0,
+    #[cfg(Py_GIL_DISABLED)]
+    ob_mutex: PyMutex {
+        _bits: AtomicU8::new(0),
+        _pin: PhantomPinned,
+    },
+    #[cfg(Py_GIL_DISABLED)]
+    ob_gc_bits: 0,
+    #[cfg(Py_GIL_DISABLED)]
+    ob_ref_local: AtomicU32::new(refcount::_Py_IMMORTAL_REFCNT_LOCAL),
+    #[cfg(Py_GIL_DISABLED)]
+    ob_ref_shared: AtomicIsize::new(0),
+    #[cfg(all(not(Py_GIL_DISABLED), Py_3_12))]
+    ob_refcnt: PyObjectObRefcnt { ob_refcnt: 1 },
+    #[cfg(not(Py_3_12))]
+    ob_refcnt: 1,
+    #[cfg(PyPy)]
+    ob_pypy_link: 0,
+    ob_type: std::ptr::null_mut(),
+};
+
+// skipped _Py_UNOWNED_TID
+
+// skipped _PyObject_CAST
 
 #[repr(C)]
 #[derive(Debug)]
@@ -137,54 +147,36 @@ pub struct PyVarObject {
 // skipped private _PyVarObject_CAST
 
 #[inline]
-#[cfg(not(all(PyPy, Py_3_10)))]
+#[cfg(not(any(GraalPy, all(PyPy, Py_3_10))))]
 #[cfg_attr(docsrs, doc(cfg(all())))]
 pub unsafe fn Py_Is(x: *mut PyObject, y: *mut PyObject) -> c_int {
     (x == y).into()
 }
 
-#[cfg(all(PyPy, Py_3_10))]
+#[cfg(any(GraalPy, all(PyPy, Py_3_10)))]
 #[cfg_attr(docsrs, doc(cfg(all())))]
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPy_Is")]
     pub fn Py_Is(x: *mut PyObject, y: *mut PyObject) -> c_int;
 }
 
-// skipped private _Py_GetThreadLocal_Addr
+// skipped _Py_GetThreadLocal_Addr
 
-// skipped private _Py_ThreadId
+// skipped _Py_ThreadID
 
-// skipped private _Py_IsOwnedByCurrentThread
+// skipped _Py_IsOwnedByCurrentThread
 
-#[inline]
-pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
-    #[cfg(Py_GIL_DISABLED)]
-    {
-        let local = (*ob).ob_ref_local.load(Relaxed);
-        if local == _Py_IMMORTAL_REFCNT_LOCAL {
-            return _Py_IMMORTAL_REFCNT;
-        }
-        let shared = (*ob).ob_ref_shared.load(Relaxed);
-        local as Py_ssize_t + Py_ssize_t::from(shared >> _Py_REF_SHARED_SHIFT)
-    }
-
-    #[cfg(all(not(Py_GIL_DISABLED), Py_3_12))]
-    {
-        (*ob).ob_refcnt.ob_refcnt
-    }
-
-    #[cfg(all(not(Py_GIL_DISABLED), not(Py_3_12), not(GraalPy)))]
-    {
-        (*ob).ob_refcnt
-    }
+#[cfg(GraalPy)]
+extern "C" {
+    #[cfg(GraalPy)]
+    fn _Py_TYPE(arg1: *const PyObject) -> *mut PyTypeObject;
 
-    #[cfg(all(not(Py_GIL_DISABLED), not(Py_3_12), GraalPy))]
-    {
-        _Py_REFCNT(ob)
-    }
+    #[cfg(GraalPy)]
+    fn _Py_SIZE(arg1: *const PyObject) -> Py_ssize_t;
 }
 
 #[inline]
+#[cfg(not(Py_3_14))]
 pub unsafe fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject {
     #[cfg(not(GraalPy))]
     return (*ob).ob_type;
@@ -192,6 +184,15 @@ pub unsafe fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject {
     return _Py_TYPE(ob);
 }
 
+#[cfg_attr(windows, link(name = "pythonXY"))]
+#[cfg(Py_3_14)]
+extern "C" {
+    #[cfg_attr(PyPy, link_name = "PyPy_TYPE")]
+    pub fn Py_TYPE(ob: *mut PyObject) -> *mut PyTypeObject;
+}
+
+// skip _Py_TYPE compat shim
+
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
     #[cfg_attr(PyPy, link_name = "PyPyLong_Type")]
@@ -212,29 +213,11 @@ pub unsafe fn Py_SIZE(ob: *mut PyObject) -> Py_ssize_t {
     _Py_SIZE(ob)
 }
 
-#[inline(always)]
-#[cfg(all(Py_3_12, not(Py_GIL_DISABLED)))]
-unsafe fn _Py_IsImmortal(op: *mut PyObject) -> c_int {
-    #[cfg(target_pointer_width = "64")]
-    {
-        (((*op).ob_refcnt.ob_refcnt as crate::PY_INT32_T) < 0) as c_int
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    {
-        ((*op).ob_refcnt.ob_refcnt == _Py_IMMORTAL_REFCNT) as c_int
-    }
-}
-
 #[inline]
 pub unsafe fn Py_IS_TYPE(ob: *mut PyObject, tp: *mut PyTypeObject) -> c_int {
     (Py_TYPE(ob) == tp) as c_int
 }
 
-// skipped _Py_SetRefCnt
-
-// skipped Py_SET_REFCNT
-
 // skipped Py_SET_TYPE
 
 // skipped Py_SET_SIZE
@@ -586,222 +569,6 @@ pub const Py_TPFLAGS_DEFAULT: c_ulong = if cfg!(Py_3_10) {
 pub const Py_TPFLAGS_HAVE_FINALIZE: c_ulong = 1;
 pub const Py_TPFLAGS_HAVE_VERSION_TAG: c_ulong = 1 << 18;
 
-extern "C" {
-    #[cfg(all(py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
-    fn _Py_NegativeRefcount(filename: *const c_char, lineno: c_int, op: *mut PyObject);
-    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
-    fn _Py_INCREF_IncRefTotal();
-    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
-    fn _Py_DECREF_DecRefTotal();
-
-    #[cfg_attr(PyPy, link_name = "_PyPy_Dealloc")]
-    fn _Py_Dealloc(arg1: *mut PyObject);
-
-    #[cfg_attr(PyPy, link_name = "PyPy_IncRef")]
-    #[cfg_attr(GraalPy, link_name = "_Py_IncRef")]
-    pub fn Py_IncRef(o: *mut PyObject);
-    #[cfg_attr(PyPy, link_name = "PyPy_DecRef")]
-    #[cfg_attr(GraalPy, link_name = "_Py_DecRef")]
-    pub fn Py_DecRef(o: *mut PyObject);
-
-    #[cfg(all(Py_3_10, not(PyPy)))]
-    fn _Py_IncRef(o: *mut PyObject);
-    #[cfg(all(Py_3_10, not(PyPy)))]
-    fn _Py_DecRef(o: *mut PyObject);
-
-    #[cfg(GraalPy)]
-    fn _Py_REFCNT(arg1: *const PyObject) -> Py_ssize_t;
-
-    #[cfg(GraalPy)]
-    fn _Py_TYPE(arg1: *const PyObject) -> *mut PyTypeObject;
-
-    #[cfg(GraalPy)]
-    fn _Py_SIZE(arg1: *const PyObject) -> Py_ssize_t;
-}
-
-#[inline(always)]
-pub unsafe fn Py_INCREF(op: *mut PyObject) {
-    // On limited API, the free-threaded build, or with refcount debugging, let the interpreter do refcounting
-    // TODO: reimplement the logic in the header in the free-threaded build, for a little bit of performance.
-    #[cfg(any(
-        Py_GIL_DISABLED,
-        Py_LIMITED_API,
-        py_sys_config = "Py_REF_DEBUG",
-        GraalPy
-    ))]
-    {
-        // _Py_IncRef was added to the ABI in 3.10; skips null checks
-        #[cfg(all(Py_3_10, not(PyPy)))]
-        {
-            _Py_IncRef(op);
-        }
-
-        #[cfg(any(not(Py_3_10), PyPy))]
-        {
-            Py_IncRef(op);
-        }
-    }
-
-    // version-specific builds are allowed to directly manipulate the reference count
-    #[cfg(not(any(
-        Py_GIL_DISABLED,
-        Py_LIMITED_API,
-        py_sys_config = "Py_REF_DEBUG",
-        GraalPy
-    )))]
-    {
-        #[cfg(all(Py_3_12, target_pointer_width = "64"))]
-        {
-            let cur_refcnt = (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN];
-            let new_refcnt = cur_refcnt.wrapping_add(1);
-            if new_refcnt == 0 {
-                return;
-            }
-            (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN] = new_refcnt;
-        }
-
-        #[cfg(all(Py_3_12, target_pointer_width = "32"))]
-        {
-            if _Py_IsImmortal(op) != 0 {
-                return;
-            }
-            (*op).ob_refcnt.ob_refcnt += 1
-        }
-
-        #[cfg(not(Py_3_12))]
-        {
-            (*op).ob_refcnt += 1
-        }
-
-        // Skipped _Py_INCREF_STAT_INC - if anyone wants this, please file an issue
-        // or submit a PR supporting Py_STATS build option and pystats.h
-    }
-}
-
-#[inline(always)]
-#[cfg_attr(
-    all(py_sys_config = "Py_REF_DEBUG", Py_3_12, not(Py_LIMITED_API)),
-    track_caller
-)]
-pub unsafe fn Py_DECREF(op: *mut PyObject) {
-    // On limited API, the free-threaded build, or with refcount debugging, let the interpreter do refcounting
-    // On 3.12+ we implement refcount debugging to get better assertion locations on negative refcounts
-    // TODO: reimplement the logic in the header in the free-threaded build, for a little bit of performance.
-    #[cfg(any(
-        Py_GIL_DISABLED,
-        Py_LIMITED_API,
-        all(py_sys_config = "Py_REF_DEBUG", not(Py_3_12)),
-        GraalPy
-    ))]
-    {
-        // _Py_DecRef was added to the ABI in 3.10; skips null checks
-        #[cfg(all(Py_3_10, not(PyPy)))]
-        {
-            _Py_DecRef(op);
-        }
-
-        #[cfg(any(not(Py_3_10), PyPy))]
-        {
-            Py_DecRef(op);
-        }
-    }
-
-    #[cfg(not(any(
-        Py_GIL_DISABLED,
-        Py_LIMITED_API,
-        all(py_sys_config = "Py_REF_DEBUG", not(Py_3_12)),
-        GraalPy
-    )))]
-    {
-        #[cfg(Py_3_12)]
-        if _Py_IsImmortal(op) != 0 {
-            return;
-        }
-
-        // Skipped _Py_DECREF_STAT_INC - if anyone needs this, please file an issue
-        // or submit a PR supporting Py_STATS build option and pystats.h
-
-        #[cfg(py_sys_config = "Py_REF_DEBUG")]
-        _Py_DECREF_DecRefTotal();
-
-        #[cfg(Py_3_12)]
-        {
-            (*op).ob_refcnt.ob_refcnt -= 1;
-
-            #[cfg(py_sys_config = "Py_REF_DEBUG")]
-            if (*op).ob_refcnt.ob_refcnt < 0 {
-                let location = std::panic::Location::caller();
-                let filename = std::ffi::CString::new(location.file()).unwrap();
-                _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op);
-            }
-
-            if (*op).ob_refcnt.ob_refcnt == 0 {
-                _Py_Dealloc(op);
-            }
-        }
-
-        #[cfg(not(Py_3_12))]
-        {
-            (*op).ob_refcnt -= 1;
-
-            if (*op).ob_refcnt == 0 {
-                _Py_Dealloc(op);
-            }
-        }
-    }
-}
-
-#[inline]
-pub unsafe fn Py_CLEAR(op: *mut *mut PyObject) {
-    let tmp = *op;
-    if !tmp.is_null() {
-        *op = ptr::null_mut();
-        Py_DECREF(tmp);
-    }
-}
-
-#[inline]
-pub unsafe fn Py_XINCREF(op: *mut PyObject) {
-    if !op.is_null() {
-        Py_INCREF(op)
-    }
-}
-
-#[inline]
-pub unsafe fn Py_XDECREF(op: *mut PyObject) {
-    if !op.is_null() {
-        Py_DECREF(op)
-    }
-}
-
-extern "C" {
-    #[cfg(all(Py_3_10, Py_LIMITED_API, not(PyPy)))]
-    #[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
-    pub fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject;
-    #[cfg(all(Py_3_10, Py_LIMITED_API, not(PyPy)))]
-    #[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
-    pub fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject;
-}
-
-// macro _Py_NewRef not public; reimplemented directly inside Py_NewRef here
-// macro _Py_XNewRef not public; reimplemented directly inside Py_XNewRef here
-
-#[cfg(all(Py_3_10, any(not(Py_LIMITED_API), PyPy)))]
-#[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
-#[inline]
-pub unsafe fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject {
-    Py_INCREF(obj);
-    obj
-}
-
-#[cfg(all(Py_3_10, any(not(Py_LIMITED_API), PyPy)))]
-#[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
-#[inline]
-pub unsafe fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject {
-    Py_XINCREF(obj);
-    obj
-}
-
 #[cfg(Py_3_13)]
 pub const Py_CONSTANT_NONE: c_uint = 0;
 #[cfg(Py_3_13)]
@@ -942,4 +709,7 @@ extern "C" {
         arg1: *mut crate::PyTypeObject,
         arg2: *mut crate::PyModuleDef,
     ) -> *mut PyObject;
+
+    #[cfg(Py_3_14)]
+    pub fn PyType_Freeze(tp: *mut crate::PyTypeObject) -> c_int;
 }
diff --git a/pyo3-ffi/src/pyarena.rs b/pyo3-ffi/src/pyarena.rs
index 87d5f28a7a5..1200de3df48 100644
--- a/pyo3-ffi/src/pyarena.rs
+++ b/pyo3-ffi/src/pyarena.rs
@@ -1 +1 @@
-opaque_struct!(PyArena);
+opaque_struct!(pub PyArena);
diff --git a/pyo3-ffi/src/pyframe.rs b/pyo3-ffi/src/pyframe.rs
index 4dd3d2b31a5..1693b20b0af 100644
--- a/pyo3-ffi/src/pyframe.rs
+++ b/pyo3-ffi/src/pyframe.rs
@@ -6,7 +6,7 @@ use crate::PyFrameObject;
 use std::os::raw::c_int;
 
 #[cfg(Py_LIMITED_API)]
-opaque_struct!(PyFrameObject);
+opaque_struct!(pub PyFrameObject);
 
 extern "C" {
     pub fn PyFrame_GetLineNumber(f: *mut PyFrameObject) -> c_int;
diff --git a/pyo3-ffi/src/pyhash.rs b/pyo3-ffi/src/pyhash.rs
index 4f14e04a695..074278ddf3c 100644
--- a/pyo3-ffi/src/pyhash.rs
+++ b/pyo3-ffi/src/pyhash.rs
@@ -1,7 +1,5 @@
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 use crate::pyport::{Py_hash_t, Py_ssize_t};
-#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
-use std::os::raw::c_char;
 #[cfg(not(any(Py_LIMITED_API, PyPy)))]
 use std::os::raw::c_void;
 
@@ -22,29 +20,6 @@ pub const _PyHASH_MULTIPLIER: c_ulong = 1000003;
 
 // skipped non-limited _Py_HashSecret_t
 
-#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct PyHash_FuncDef {
-    pub hash: Option<extern "C" fn(arg1: *const c_void, arg2: Py_ssize_t) -> Py_hash_t>,
-    pub name: *const c_char,
-    pub hash_bits: c_int,
-    pub seed_bits: c_int,
-}
-
-#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
-impl Default for PyHash_FuncDef {
-    #[inline]
-    fn default() -> Self {
-        unsafe { std::mem::zeroed() }
-    }
-}
-
-extern "C" {
-    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
-    pub fn PyHash_GetFuncDef() -> *mut PyHash_FuncDef;
-}
-
 // skipped Py_HASH_CUTOFF
 
 pub const Py_HASH_EXTERNAL: c_int = 0;
diff --git a/pyo3-ffi/src/pyport.rs b/pyo3-ffi/src/pyport.rs
index a144c67fb1b..e524831d80d 100644
--- a/pyo3-ffi/src/pyport.rs
+++ b/pyo3-ffi/src/pyport.rs
@@ -1,3 +1,8 @@
+// NB libc does not define this constant on all platforms, so we hard code it
+// like CPython does.
+// https://github.com/python/cpython/blob/d8b9011702443bb57579f8834f3effe58e290dfc/Include/pyport.h#L372
+pub const INT_MAX: std::os::raw::c_int = 2147483647;
+
 pub type PY_UINT32_T = u32;
 pub type PY_UINT64_T = u64;
 
@@ -11,8 +16,8 @@ pub type Py_ssize_t = ::libc::ssize_t;
 pub type Py_hash_t = Py_ssize_t;
 pub type Py_uhash_t = ::libc::size_t;
 
-pub const PY_SSIZE_T_MIN: Py_ssize_t = isize::MIN as Py_ssize_t;
-pub const PY_SSIZE_T_MAX: Py_ssize_t = isize::MAX as Py_ssize_t;
+pub const PY_SSIZE_T_MIN: Py_ssize_t = Py_ssize_t::MIN;
+pub const PY_SSIZE_T_MAX: Py_ssize_t = Py_ssize_t::MAX;
 
 #[cfg(target_endian = "big")]
 pub const PY_BIG_ENDIAN: usize = 1;
diff --git a/pyo3-ffi/src/pystate.rs b/pyo3-ffi/src/pystate.rs
index a6caf421ff6..cc16e554ca9 100644
--- a/pyo3-ffi/src/pystate.rs
+++ b/pyo3-ffi/src/pystate.rs
@@ -9,8 +9,8 @@ use std::os::raw::c_long;
 
 pub const MAX_CO_EXTRA_USERS: c_int = 255;
 
-opaque_struct!(PyThreadState);
-opaque_struct!(PyInterpreterState);
+opaque_struct!(pub PyThreadState);
+opaque_struct!(pub PyInterpreterState);
 
 extern "C" {
     #[cfg(not(PyPy))]
@@ -80,17 +80,14 @@ pub enum PyGILState_STATE {
     PyGILState_UNLOCKED,
 }
 
+#[cfg(not(Py_3_14))]
 struct HangThread;
 
+#[cfg(not(Py_3_14))]
 impl Drop for HangThread {
     fn drop(&mut self) {
         loop {
-            #[cfg(target_family = "unix")]
-            unsafe {
-                libc::pause();
-            }
-            #[cfg(not(target_family = "unix"))]
-            std::thread::sleep(std::time::Duration::from_secs(9_999_999));
+            std::thread::park(); // Block forever.
         }
     }
 }
diff --git a/pyo3-ffi/src/pythonrun.rs b/pyo3-ffi/src/pythonrun.rs
index e7ea2d2efd0..80209b5875a 100644
--- a/pyo3-ffi/src/pythonrun.rs
+++ b/pyo3-ffi/src/pythonrun.rs
@@ -49,12 +49,12 @@ pub const PYOS_STACK_MARGIN: c_int = 2048;
 // skipped PyOS_CheckStack under Microsoft C
 
 #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
-opaque_struct!(_mod);
+opaque_struct!(pub _mod);
 
 #[cfg(not(any(PyPy, Py_3_10)))]
-opaque_struct!(symtable);
+opaque_struct!(pub symtable);
 #[cfg(not(any(PyPy, Py_3_10)))]
-opaque_struct!(_node);
+opaque_struct!(pub _node);
 
 #[cfg(not(any(PyPy, Py_LIMITED_API, Py_3_10)))]
 #[cfg_attr(Py_3_9, deprecated(note = "Python 3.9"))]
diff --git a/pyo3-ffi/src/refcount.rs b/pyo3-ffi/src/refcount.rs
new file mode 100644
index 00000000000..fcb5f45be6a
--- /dev/null
+++ b/pyo3-ffi/src/refcount.rs
@@ -0,0 +1,369 @@
+use crate::pyport::Py_ssize_t;
+use crate::PyObject;
+#[cfg(py_sys_config = "Py_REF_DEBUG")]
+use std::os::raw::c_char;
+#[cfg(Py_3_12)]
+use std::os::raw::c_int;
+#[cfg(all(Py_3_14, any(not(Py_GIL_DISABLED), target_pointer_width = "32")))]
+use std::os::raw::c_long;
+#[cfg(any(Py_GIL_DISABLED, all(Py_3_12, not(Py_3_14))))]
+use std::os::raw::c_uint;
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
+use std::os::raw::c_ulong;
+use std::ptr;
+#[cfg(Py_GIL_DISABLED)]
+use std::sync::atomic::Ordering::Relaxed;
+
+#[cfg(Py_3_14)]
+const _Py_STATICALLY_ALLOCATED_FLAG: c_int = 1 << 7;
+
+#[cfg(all(Py_3_12, not(Py_3_14)))]
+const _Py_IMMORTAL_REFCNT: Py_ssize_t = {
+    if cfg!(target_pointer_width = "64") {
+        c_uint::MAX as Py_ssize_t
+    } else {
+        // for 32-bit systems, use the lower 30 bits (see comment in CPython's object.h)
+        (c_uint::MAX >> 2) as Py_ssize_t
+    }
+};
+
+// comments in Python.h about the choices for these constants
+
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
+const _Py_IMMORTAL_INITIAL_REFCNT: Py_ssize_t = {
+    if cfg!(target_pointer_width = "64") {
+        ((3 as c_ulong) << (30 as c_ulong)) as Py_ssize_t
+    } else {
+        ((5 as c_long) << (28 as c_long)) as Py_ssize_t
+    }
+};
+
+#[cfg(all(Py_3_14, not(Py_GIL_DISABLED)))]
+const _Py_STATIC_IMMORTAL_INITIAL_REFCNT: Py_ssize_t = {
+    if cfg!(target_pointer_width = "64") {
+        _Py_IMMORTAL_INITIAL_REFCNT
+            | ((_Py_STATICALLY_ALLOCATED_FLAG as Py_ssize_t) << (32 as Py_ssize_t))
+    } else {
+        ((7 as c_long) << (28 as c_long)) as Py_ssize_t
+    }
+};
+
+#[cfg(all(Py_3_14, target_pointer_width = "32"))]
+const _Py_IMMORTAL_MINIMUM_REFCNT: Py_ssize_t = ((1 as c_long) << (30 as c_long)) as Py_ssize_t;
+
+#[cfg(all(Py_3_14, target_pointer_width = "32"))]
+const _Py_STATIC_IMMORTAL_MINIMUM_REFCNT: Py_ssize_t =
+    ((6 as c_long) << (28 as c_long)) as Py_ssize_t;
+
+#[cfg(all(Py_3_14, Py_GIL_DISABLED))]
+const _Py_IMMORTAL_INITIAL_REFCNT: Py_ssize_t = c_uint::MAX as Py_ssize_t;
+
+#[cfg(Py_GIL_DISABLED)]
+pub(crate) const _Py_IMMORTAL_REFCNT_LOCAL: u32 = u32::MAX;
+
+#[cfg(Py_GIL_DISABLED)]
+const _Py_REF_SHARED_SHIFT: isize = 2;
+// skipped private _Py_REF_SHARED_FLAG_MASK
+
+// skipped private _Py_REF_SHARED_INIT
+// skipped private _Py_REF_MAYBE_WEAKREF
+// skipped private _Py_REF_QUEUED
+// skipped private _Py_REF_MERGED
+
+// skipped private _Py_REF_SHARED
+
+extern "C" {
+    #[cfg(all(Py_3_14, Py_LIMITED_API))]
+    pub fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t;
+}
+
+#[cfg(not(all(Py_3_14, Py_LIMITED_API)))]
+#[inline]
+pub unsafe fn Py_REFCNT(ob: *mut PyObject) -> Py_ssize_t {
+    #[cfg(Py_GIL_DISABLED)]
+    {
+        let local = (*ob).ob_ref_local.load(Relaxed);
+        if local == _Py_IMMORTAL_REFCNT_LOCAL {
+            #[cfg(not(Py_3_14))]
+            return _Py_IMMORTAL_REFCNT;
+            #[cfg(Py_3_14)]
+            return _Py_IMMORTAL_INITIAL_REFCNT;
+        }
+        let shared = (*ob).ob_ref_shared.load(Relaxed);
+        local as Py_ssize_t + Py_ssize_t::from(shared >> _Py_REF_SHARED_SHIFT)
+    }
+
+    #[cfg(all(Py_LIMITED_API, Py_3_14))]
+    {
+        Py_REFCNT(ob)
+    }
+
+    #[cfg(all(not(Py_GIL_DISABLED), not(all(Py_LIMITED_API, Py_3_14)), Py_3_12))]
+    {
+        (*ob).ob_refcnt.ob_refcnt
+    }
+
+    #[cfg(all(not(Py_GIL_DISABLED), not(Py_3_12), not(GraalPy)))]
+    {
+        (*ob).ob_refcnt
+    }
+
+    #[cfg(all(not(Py_GIL_DISABLED), not(Py_3_12), GraalPy))]
+    {
+        _Py_REFCNT(ob)
+    }
+}
+
+#[cfg(Py_3_12)]
+#[inline(always)]
+unsafe fn _Py_IsImmortal(op: *mut PyObject) -> c_int {
+    #[cfg(all(target_pointer_width = "64", not(Py_GIL_DISABLED)))]
+    {
+        (((*op).ob_refcnt.ob_refcnt as crate::PY_INT32_T) < 0) as c_int
+    }
+
+    #[cfg(all(target_pointer_width = "32", not(Py_GIL_DISABLED)))]
+    {
+        #[cfg(not(Py_3_14))]
+        {
+            ((*op).ob_refcnt.ob_refcnt == _Py_IMMORTAL_REFCNT) as c_int
+        }
+
+        #[cfg(Py_3_14)]
+        {
+            ((*op).ob_refcnt.ob_refcnt >= _Py_IMMORTAL_MINIMUM_REFCNT) as c_int
+        }
+    }
+
+    #[cfg(Py_GIL_DISABLED)]
+    {
+        ((*op).ob_ref_local.load(Relaxed) == _Py_IMMORTAL_REFCNT_LOCAL) as c_int
+    }
+}
+
+// skipped _Py_IsStaticImmortal
+
+// TODO: Py_SET_REFCNT
+
+extern "C" {
+    #[cfg(all(py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
+    fn _Py_NegativeRefcount(filename: *const c_char, lineno: c_int, op: *mut PyObject);
+    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
+    fn _Py_INCREF_IncRefTotal();
+    #[cfg(all(Py_3_12, py_sys_config = "Py_REF_DEBUG", not(Py_LIMITED_API)))]
+    fn _Py_DECREF_DecRefTotal();
+
+    #[cfg_attr(PyPy, link_name = "_PyPy_Dealloc")]
+    fn _Py_Dealloc(arg1: *mut PyObject);
+
+    #[cfg_attr(PyPy, link_name = "PyPy_IncRef")]
+    #[cfg_attr(GraalPy, link_name = "_Py_IncRef")]
+    pub fn Py_IncRef(o: *mut PyObject);
+    #[cfg_attr(PyPy, link_name = "PyPy_DecRef")]
+    #[cfg_attr(GraalPy, link_name = "_Py_DecRef")]
+    pub fn Py_DecRef(o: *mut PyObject);
+
+    #[cfg(all(Py_3_10, not(PyPy)))]
+    fn _Py_IncRef(o: *mut PyObject);
+    #[cfg(all(Py_3_10, not(PyPy)))]
+    fn _Py_DecRef(o: *mut PyObject);
+
+    #[cfg(GraalPy)]
+    fn _Py_REFCNT(arg1: *const PyObject) -> Py_ssize_t;
+}
+
+#[inline(always)]
+pub unsafe fn Py_INCREF(op: *mut PyObject) {
+    // On limited API, the free-threaded build, or with refcount debugging, let the interpreter do refcounting
+    // TODO: reimplement the logic in the header in the free-threaded build, for a little bit of performance.
+    #[cfg(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        py_sys_config = "Py_REF_DEBUG",
+        GraalPy
+    ))]
+    {
+        // _Py_IncRef was added to the ABI in 3.10; skips null checks
+        #[cfg(all(Py_3_10, not(PyPy)))]
+        {
+            _Py_IncRef(op);
+        }
+
+        #[cfg(any(not(Py_3_10), PyPy))]
+        {
+            Py_IncRef(op);
+        }
+    }
+
+    // version-specific builds are allowed to directly manipulate the reference count
+    #[cfg(not(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        py_sys_config = "Py_REF_DEBUG",
+        GraalPy
+    )))]
+    {
+        #[cfg(all(Py_3_14, target_pointer_width = "64"))]
+        {
+            let cur_refcnt = (*op).ob_refcnt.ob_refcnt;
+            if (cur_refcnt as i32) < 0 {
+                return;
+            }
+            (*op).ob_refcnt.ob_refcnt = cur_refcnt.wrapping_add(1);
+        }
+
+        #[cfg(all(Py_3_12, not(Py_3_14), target_pointer_width = "64"))]
+        {
+            let cur_refcnt = (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN];
+            let new_refcnt = cur_refcnt.wrapping_add(1);
+            if new_refcnt == 0 {
+                return;
+            }
+            (*op).ob_refcnt.ob_refcnt_split[crate::PY_BIG_ENDIAN] = new_refcnt;
+        }
+
+        #[cfg(all(Py_3_12, target_pointer_width = "32"))]
+        {
+            if _Py_IsImmortal(op) != 0 {
+                return;
+            }
+            (*op).ob_refcnt.ob_refcnt += 1
+        }
+
+        #[cfg(not(Py_3_12))]
+        {
+            (*op).ob_refcnt += 1
+        }
+
+        // Skipped _Py_INCREF_STAT_INC - if anyone wants this, please file an issue
+        // or submit a PR supporting Py_STATS build option and pystats.h
+    }
+}
+
+// skipped _Py_DecRefShared
+// skipped _Py_DecRefSharedDebug
+// skipped _Py_MergeZeroLocalRefcount
+
+#[inline(always)]
+#[cfg_attr(
+    all(py_sys_config = "Py_REF_DEBUG", Py_3_12, not(Py_LIMITED_API)),
+    track_caller
+)]
+pub unsafe fn Py_DECREF(op: *mut PyObject) {
+    // On limited API, the free-threaded build, or with refcount debugging, let the interpreter do refcounting
+    // On 3.12+ we implement refcount debugging to get better assertion locations on negative refcounts
+    // TODO: reimplement the logic in the header in the free-threaded build, for a little bit of performance.
+    #[cfg(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        all(py_sys_config = "Py_REF_DEBUG", not(Py_3_12)),
+        GraalPy
+    ))]
+    {
+        // _Py_DecRef was added to the ABI in 3.10; skips null checks
+        #[cfg(all(Py_3_10, not(PyPy)))]
+        {
+            _Py_DecRef(op);
+        }
+
+        #[cfg(any(not(Py_3_10), PyPy))]
+        {
+            Py_DecRef(op);
+        }
+    }
+
+    #[cfg(not(any(
+        Py_GIL_DISABLED,
+        Py_LIMITED_API,
+        all(py_sys_config = "Py_REF_DEBUG", not(Py_3_12)),
+        GraalPy
+    )))]
+    {
+        #[cfg(Py_3_12)]
+        if _Py_IsImmortal(op) != 0 {
+            return;
+        }
+
+        // Skipped _Py_DECREF_STAT_INC - if anyone needs this, please file an issue
+        // or submit a PR supporting Py_STATS build option and pystats.h
+
+        #[cfg(py_sys_config = "Py_REF_DEBUG")]
+        _Py_DECREF_DecRefTotal();
+
+        #[cfg(Py_3_12)]
+        {
+            (*op).ob_refcnt.ob_refcnt -= 1;
+
+            #[cfg(py_sys_config = "Py_REF_DEBUG")]
+            if (*op).ob_refcnt.ob_refcnt < 0 {
+                let location = std::panic::Location::caller();
+                let filename = std::ffi::CString::new(location.file()).unwrap();
+                _Py_NegativeRefcount(filename.as_ptr(), location.line() as i32, op);
+            }
+
+            if (*op).ob_refcnt.ob_refcnt == 0 {
+                _Py_Dealloc(op);
+            }
+        }
+
+        #[cfg(not(Py_3_12))]
+        {
+            (*op).ob_refcnt -= 1;
+
+            if (*op).ob_refcnt == 0 {
+                _Py_Dealloc(op);
+            }
+        }
+    }
+}
+
+#[inline]
+pub unsafe fn Py_CLEAR(op: *mut *mut PyObject) {
+    let tmp = *op;
+    if !tmp.is_null() {
+        *op = ptr::null_mut();
+        Py_DECREF(tmp);
+    }
+}
+
+#[inline]
+pub unsafe fn Py_XINCREF(op: *mut PyObject) {
+    if !op.is_null() {
+        Py_INCREF(op)
+    }
+}
+
+#[inline]
+pub unsafe fn Py_XDECREF(op: *mut PyObject) {
+    if !op.is_null() {
+        Py_DECREF(op)
+    }
+}
+
+extern "C" {
+    #[cfg(all(Py_3_10, Py_LIMITED_API, not(PyPy)))]
+    #[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+    pub fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject;
+    #[cfg(all(Py_3_10, Py_LIMITED_API, not(PyPy)))]
+    #[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+    pub fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject;
+}
+
+// macro _Py_NewRef not public; reimplemented directly inside Py_NewRef here
+// macro _Py_XNewRef not public; reimplemented directly inside Py_XNewRef here
+
+#[cfg(all(Py_3_10, any(not(Py_LIMITED_API), PyPy)))]
+#[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+#[inline]
+pub unsafe fn Py_NewRef(obj: *mut PyObject) -> *mut PyObject {
+    Py_INCREF(obj);
+    obj
+}
+
+#[cfg(all(Py_3_10, any(not(Py_LIMITED_API), PyPy)))]
+#[cfg_attr(docsrs, doc(cfg(Py_3_10)))]
+#[inline]
+pub unsafe fn Py_XNewRef(obj: *mut PyObject) -> *mut PyObject {
+    Py_XINCREF(obj);
+    obj
+}
diff --git a/pyo3-ffi/src/setobject.rs b/pyo3-ffi/src/setobject.rs
index 9d5351fc798..87e33e803f4 100644
--- a/pyo3-ffi/src/setobject.rs
+++ b/pyo3-ffi/src/setobject.rs
@@ -39,11 +39,7 @@ pub unsafe fn PySet_GET_SIZE(so: *mut PyObject) -> Py_ssize_t {
     (*so).used
 }
 
-#[cfg(not(Py_LIMITED_API))]
-#[cfg_attr(windows, link(name = "pythonXY"))]
-extern "C" {
-    pub static mut _PySet_Dummy: *mut PyObject;
-}
+// skipped _PySet_Dummy
 
 extern "C" {
     #[cfg(not(Py_LIMITED_API))]
diff --git a/pyo3-ffi/src/weakrefobject.rs b/pyo3-ffi/src/weakrefobject.rs
index 305dc290fa8..88a1bf90314 100644
--- a/pyo3-ffi/src/weakrefobject.rs
+++ b/pyo3-ffi/src/weakrefobject.rs
@@ -4,16 +4,18 @@ use std::os::raw::c_int;
 use std::ptr::addr_of_mut;
 
 #[cfg(all(not(PyPy), Py_LIMITED_API, not(GraalPy)))]
-opaque_struct!(PyWeakReference);
+opaque_struct!(pub PyWeakReference);
 
 #[cfg(all(not(PyPy), not(Py_LIMITED_API), not(GraalPy)))]
 pub use crate::_PyWeakReference as PyWeakReference;
 
 #[cfg_attr(windows, link(name = "pythonXY"))]
 extern "C" {
+    // TODO: PyO3 is depending on this symbol in `reference.rs`, we should change this and
+    // remove the export as this is a private symbol.
     pub static mut _PyWeakref_RefType: PyTypeObject;
-    pub static mut _PyWeakref_ProxyType: PyTypeObject;
-    pub static mut _PyWeakref_CallableProxyType: PyTypeObject;
+    static mut _PyWeakref_ProxyType: PyTypeObject;
+    static mut _PyWeakref_CallableProxyType: PyTypeObject;
 
     #[cfg(PyPy)]
     #[link_name = "PyPyWeakref_CheckRef"]
diff --git a/pyo3-introspection/Cargo.toml b/pyo3-introspection/Cargo.toml
index d861ec7b6d5..98dfdebbd10 100644
--- a/pyo3-introspection/Cargo.toml
+++ b/pyo3-introspection/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-introspection"
-version = "0.25.0-dev"
+version = "0.25.0"
 description = "Introspect dynamic libraries built with PyO3 to get metadata about the exported Python types"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 homepage = "https://github.com/pyo3/pyo3"
diff --git a/pyo3-introspection/src/introspection.rs b/pyo3-introspection/src/introspection.rs
index 15fd9d92b84..665109d0a66 100644
--- a/pyo3-introspection/src/introspection.rs
+++ b/pyo3-introspection/src/introspection.rs
@@ -1,4 +1,4 @@
-use crate::model::{Class, Function, Module};
+use crate::model::{Argument, Arguments, Class, Function, Module, VariableLengthArgument};
 use anyhow::{bail, ensure, Context, Result};
 use goblin::elf::Elf;
 use goblin::mach::load_command::CommandVariant;
@@ -7,6 +7,7 @@ use goblin::mach::{Mach, MachO, SingleArch};
 use goblin::pe::PE;
 use goblin::Object;
 use serde::Deserialize;
+use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::fs;
 use std::path::Path;
@@ -21,19 +22,23 @@ pub fn introspect_cdylib(library_path: impl AsRef<Path>, main_module_name: &str)
 
 /// Parses the introspection chunks found in the binary
 fn parse_chunks(chunks: &[Chunk], main_module_name: &str) -> Result<Module> {
-    let chunks_by_id = chunks
-        .iter()
-        .map(|c| {
-            (
-                match c {
-                    Chunk::Module { id, .. } => id,
-                    Chunk::Class { id, .. } => id,
-                    Chunk::Function { id, .. } => id,
-                },
-                c,
-            )
-        })
-        .collect::<HashMap<_, _>>();
+    let mut chunks_by_id = HashMap::<&str, &Chunk>::new();
+    let mut chunks_by_parent = HashMap::<&str, Vec<&Chunk>>::new();
+    for chunk in chunks {
+        if let Some(id) = match chunk {
+            Chunk::Module { id, .. } => Some(id),
+            Chunk::Class { id, .. } => Some(id),
+            Chunk::Function { id, .. } => id.as_ref(),
+        } {
+            chunks_by_id.insert(id, chunk);
+        }
+        if let Some(parent) = match chunk {
+            Chunk::Module { .. } | Chunk::Class { .. } => None,
+            Chunk::Function { parent, .. } => parent.as_ref(),
+        } {
+            chunks_by_parent.entry(parent).or_default().push(chunk);
+        }
+    }
     // We look for the root chunk
     for chunk in chunks {
         if let Chunk::Module {
@@ -43,44 +48,149 @@ fn parse_chunks(chunks: &[Chunk], main_module_name: &str) -> Result<Module> {
         } = chunk
         {
             if name == main_module_name {
-                return parse_module(name, members, &chunks_by_id);
+                return convert_module(name, members, &chunks_by_id, &chunks_by_parent);
             }
         }
     }
     bail!("No module named {main_module_name} found")
 }
 
-fn parse_module(
+fn convert_module(
     name: &str,
     members: &[String],
-    chunks_by_id: &HashMap<&String, &Chunk>,
+    chunks_by_id: &HashMap<&str, &Chunk>,
+    chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
 ) -> Result<Module> {
+    let (modules, classes, functions) = convert_members(
+        &members
+            .iter()
+            .filter_map(|id| chunks_by_id.get(id.as_str()).copied())
+            .collect::<Vec<_>>(),
+        chunks_by_id,
+        chunks_by_parent,
+    )?;
+    Ok(Module {
+        name: name.into(),
+        modules,
+        classes,
+        functions,
+    })
+}
+
+/// Convert a list of members of a module or a class
+fn convert_members(
+    chunks: &[&Chunk],
+    chunks_by_id: &HashMap<&str, &Chunk>,
+    chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
+) -> Result<(Vec<Module>, Vec<Class>, Vec<Function>)> {
     let mut modules = Vec::new();
     let mut classes = Vec::new();
     let mut functions = Vec::new();
-    for member in members {
-        if let Some(chunk) = chunks_by_id.get(member) {
-            match chunk {
-                Chunk::Module {
+    for chunk in chunks {
+        match chunk {
+            Chunk::Module {
+                name,
+                members,
+                id: _,
+            } => {
+                modules.push(convert_module(
                     name,
                     members,
-                    id: _,
-                } => {
-                    modules.push(parse_module(name, members, chunks_by_id)?);
-                }
-                Chunk::Class { name, id: _ } => classes.push(Class { name: name.into() }),
-                Chunk::Function { name, id: _ } => functions.push(Function { name: name.into() }),
+                    chunks_by_id,
+                    chunks_by_parent,
+                )?);
             }
+            Chunk::Class { name, id } => {
+                classes.push(convert_class(id, name, chunks_by_id, chunks_by_parent)?)
+            }
+            Chunk::Function {
+                name,
+                id: _,
+                arguments,
+                parent: _,
+                decorators,
+            } => functions.push(convert_function(name, arguments, decorators)),
         }
     }
-    Ok(Module {
+    Ok((modules, classes, functions))
+}
+
+fn convert_class(
+    id: &str,
+    name: &str,
+    chunks_by_id: &HashMap<&str, &Chunk>,
+    chunks_by_parent: &HashMap<&str, Vec<&Chunk>>,
+) -> Result<Class> {
+    let (nested_modules, nested_classes, mut methods) = convert_members(
+        chunks_by_parent
+            .get(&id)
+            .map(Vec::as_slice)
+            .unwrap_or_default(),
+        chunks_by_id,
+        chunks_by_parent,
+    )?;
+    ensure!(
+        nested_modules.is_empty(),
+        "Classes cannot contain nested modules"
+    );
+    ensure!(
+        nested_classes.is_empty(),
+        "Nested classes are not supported yet"
+    );
+    // We sort methods to get a stable output
+    methods.sort_by(|l, r| match l.name.cmp(&r.name) {
+        Ordering::Equal => {
+            // We put the getter before the setter
+            if l.decorators.iter().any(|d| d == "property") {
+                Ordering::Less
+            } else if r.decorators.iter().any(|d| d == "property") {
+                Ordering::Greater
+            } else {
+                // We pick an ordering based on decorators
+                l.decorators.cmp(&r.decorators)
+            }
+        }
+        o => o,
+    });
+    Ok(Class {
         name: name.into(),
-        modules,
-        classes,
-        functions,
+        methods,
     })
 }
 
+fn convert_function(name: &str, arguments: &ChunkArguments, decorators: &[String]) -> Function {
+    Function {
+        name: name.into(),
+        decorators: decorators.to_vec(),
+        arguments: Arguments {
+            positional_only_arguments: arguments.posonlyargs.iter().map(convert_argument).collect(),
+            arguments: arguments.args.iter().map(convert_argument).collect(),
+            vararg: arguments
+                .vararg
+                .as_ref()
+                .map(convert_variable_length_argument),
+            keyword_only_arguments: arguments.kwonlyargs.iter().map(convert_argument).collect(),
+            kwarg: arguments
+                .kwarg
+                .as_ref()
+                .map(convert_variable_length_argument),
+        },
+    }
+}
+
+fn convert_argument(arg: &ChunkArgument) -> Argument {
+    Argument {
+        name: arg.name.clone(),
+        default_value: arg.default.clone(),
+    }
+}
+
+fn convert_variable_length_argument(arg: &ChunkArgument) -> VariableLengthArgument {
+    VariableLengthArgument {
+        name: arg.name.clone(),
+    }
+}
+
 fn find_introspection_chunks_in_binary_object(path: &Path) -> Result<Vec<Chunk>> {
     let library_content =
         fs::read(path).with_context(|| format!("Failed to read {}", path.display()))?;
@@ -250,7 +360,34 @@ enum Chunk {
         name: String,
     },
     Function {
-        id: String,
+        #[serde(default)]
+        id: Option<String>,
         name: String,
+        arguments: ChunkArguments,
+        #[serde(default)]
+        parent: Option<String>,
+        #[serde(default)]
+        decorators: Vec<String>,
     },
 }
+
+#[derive(Deserialize)]
+struct ChunkArguments {
+    #[serde(default)]
+    posonlyargs: Vec<ChunkArgument>,
+    #[serde(default)]
+    args: Vec<ChunkArgument>,
+    #[serde(default)]
+    vararg: Option<ChunkArgument>,
+    #[serde(default)]
+    kwonlyargs: Vec<ChunkArgument>,
+    #[serde(default)]
+    kwarg: Option<ChunkArgument>,
+}
+
+#[derive(Deserialize)]
+struct ChunkArgument {
+    name: String,
+    #[serde(default)]
+    default: Option<String>,
+}
diff --git a/pyo3-introspection/src/model.rs b/pyo3-introspection/src/model.rs
index 73a4c27d082..021475b9392 100644
--- a/pyo3-introspection/src/model.rs
+++ b/pyo3-introspection/src/model.rs
@@ -9,9 +9,40 @@ pub struct Module {
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub struct Class {
     pub name: String,
+    pub methods: Vec<Function>,
 }
 
 #[derive(Debug, Eq, PartialEq, Clone, Hash)]
 pub struct Function {
     pub name: String,
+    /// decorator like 'property' or 'staticmethod'
+    pub decorators: Vec<String>,
+    pub arguments: Arguments,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Arguments {
+    /// Arguments before /
+    pub positional_only_arguments: Vec<Argument>,
+    /// Regular arguments (between / and *)
+    pub arguments: Vec<Argument>,
+    /// *vararg
+    pub vararg: Option<VariableLengthArgument>,
+    /// Arguments after *
+    pub keyword_only_arguments: Vec<Argument>,
+    /// **kwarg
+    pub kwarg: Option<VariableLengthArgument>,
+}
+
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct Argument {
+    pub name: String,
+    /// Default value as a Python expression
+    pub default_value: Option<String>,
+}
+
+/// A variable length argument ie. *vararg or **kwarg
+#[derive(Debug, Eq, PartialEq, Clone, Hash)]
+pub struct VariableLengthArgument {
+    pub name: String,
 }
diff --git a/pyo3-introspection/src/stubs.rs b/pyo3-introspection/src/stubs.rs
index 0705911032f..cc0a11ebd38 100644
--- a/pyo3-introspection/src/stubs.rs
+++ b/pyo3-introspection/src/stubs.rs
@@ -1,4 +1,4 @@
-use crate::model::{Class, Function, Module};
+use crate::model::{Argument, Class, Function, Module, VariableLengthArgument};
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
@@ -39,14 +39,153 @@ fn module_stubs(module: &Module) -> String {
     for function in &module.functions {
         elements.push(function_stubs(function));
     }
-    elements.push(String::new()); // last line jump
-    elements.join("\n")
+
+    // We insert two line jumps (i.e. empty strings) only above and below multiple line elements (classes with methods, functions with decorators)
+    let mut output = String::new();
+    for element in elements {
+        let is_multiline = element.contains('\n');
+        if is_multiline && !output.is_empty() && !output.ends_with("\n\n") {
+            output.push('\n');
+        }
+        output.push_str(&element);
+        output.push('\n');
+        if is_multiline {
+            output.push('\n');
+        }
+    }
+    // We remove a line jump at the end if they are two
+    if output.ends_with("\n\n") {
+        output.pop();
+    }
+    output
 }
 
 fn class_stubs(class: &Class) -> String {
-    format!("class {}: ...", class.name)
+    let mut buffer = format!("class {}:", class.name);
+    if class.methods.is_empty() {
+        buffer.push_str(" ...");
+        return buffer;
+    }
+    for method in &class.methods {
+        // We do the indentation
+        buffer.push_str("\n    ");
+        buffer.push_str(&function_stubs(method).replace('\n', "\n    "));
+    }
+    buffer
 }
 
 fn function_stubs(function: &Function) -> String {
-    format!("def {}(*args, **kwargs): ...", function.name)
+    // Signature
+    let mut parameters = Vec::new();
+    for argument in &function.arguments.positional_only_arguments {
+        parameters.push(argument_stub(argument));
+    }
+    if !function.arguments.positional_only_arguments.is_empty() {
+        parameters.push("/".into());
+    }
+    for argument in &function.arguments.arguments {
+        parameters.push(argument_stub(argument));
+    }
+    if let Some(argument) = &function.arguments.vararg {
+        parameters.push(format!("*{}", variable_length_argument_stub(argument)));
+    } else if !function.arguments.keyword_only_arguments.is_empty() {
+        parameters.push("*".into());
+    }
+    for argument in &function.arguments.keyword_only_arguments {
+        parameters.push(argument_stub(argument));
+    }
+    if let Some(argument) = &function.arguments.kwarg {
+        parameters.push(format!("**{}", variable_length_argument_stub(argument)));
+    }
+    let output = format!("def {}({}): ...", function.name, parameters.join(", "));
+    if function.decorators.is_empty() {
+        return output;
+    }
+    let mut buffer = String::new();
+    for decorator in &function.decorators {
+        buffer.push('@');
+        buffer.push_str(decorator);
+        buffer.push('\n');
+    }
+    buffer.push_str(&output);
+    buffer
+}
+
+fn argument_stub(argument: &Argument) -> String {
+    let mut output = argument.name.clone();
+    if let Some(default_value) = &argument.default_value {
+        output.push('=');
+        output.push_str(default_value);
+    }
+    output
+}
+
+fn variable_length_argument_stub(argument: &VariableLengthArgument) -> String {
+    argument.name.clone()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::model::Arguments;
+
+    #[test]
+    fn function_stubs_with_variable_length() {
+        let function = Function {
+            name: "func".into(),
+            decorators: Vec::new(),
+            arguments: Arguments {
+                positional_only_arguments: vec![Argument {
+                    name: "posonly".into(),
+                    default_value: None,
+                }],
+                arguments: vec![Argument {
+                    name: "arg".into(),
+                    default_value: None,
+                }],
+                vararg: Some(VariableLengthArgument {
+                    name: "varargs".into(),
+                }),
+                keyword_only_arguments: vec![Argument {
+                    name: "karg".into(),
+                    default_value: None,
+                }],
+                kwarg: Some(VariableLengthArgument {
+                    name: "kwarg".into(),
+                }),
+            },
+        };
+        assert_eq!(
+            "def func(posonly, /, arg, *varargs, karg, **kwarg): ...",
+            function_stubs(&function)
+        )
+    }
+
+    #[test]
+    fn function_stubs_without_variable_length() {
+        let function = Function {
+            name: "afunc".into(),
+            decorators: Vec::new(),
+            arguments: Arguments {
+                positional_only_arguments: vec![Argument {
+                    name: "posonly".into(),
+                    default_value: Some("1".into()),
+                }],
+                arguments: vec![Argument {
+                    name: "arg".into(),
+                    default_value: Some("True".into()),
+                }],
+                vararg: None,
+                keyword_only_arguments: vec![Argument {
+                    name: "karg".into(),
+                    default_value: Some("\"foo\"".into()),
+                }],
+                kwarg: None,
+            },
+        };
+        assert_eq!(
+            "def afunc(posonly=1, /, arg=True, *, karg=\"foo\"): ...",
+            function_stubs(&function)
+        )
+    }
 }
diff --git a/pyo3-introspection/tests/test.rs b/pyo3-introspection/tests/test.rs
index 37070a53a13..302efd1ea47 100644
--- a/pyo3-introspection/tests/test.rs
+++ b/pyo3-introspection/tests/test.rs
@@ -42,9 +42,10 @@ fn pytests_stubs() -> Result<()> {
                 file_name.display()
             )
         });
+        // We normalize line jumps for compatibility with Windows
         assert_eq!(
-            &expected_file_content.replace('\r', ""), // Windows compatibility
-            actual_file_content,
+            expected_file_content.replace('\r', ""),
+            actual_file_content.replace('\r', ""),
             "The content of file {} is different",
             file_name.display()
         )
diff --git a/pyo3-macros-backend/Cargo.toml b/pyo3-macros-backend/Cargo.toml
index 5730df1ae1d..d626fa1ebf7 100644
--- a/pyo3-macros-backend/Cargo.toml
+++ b/pyo3-macros-backend/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-macros-backend"
-version = "0.25.0-dev"
+version = "0.25.0"
 description = "Code generation for PyO3 package"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -17,7 +17,7 @@ rust-version = "1.63"
 [dependencies]
 heck = "0.5"
 proc-macro2 = { version = "1.0.60", default-features = false }
-pyo3-build-config = { path = "../pyo3-build-config", version = "=0.25.0-dev", features = ["resolve-config"] }
+pyo3-build-config = { path = "../pyo3-build-config", version = "=0.25.0", features = ["resolve-config"] }
 quote = { version = "1", default-features = false }
 
 [dependencies.syn]
@@ -26,7 +26,7 @@ default-features = false
 features = ["derive", "parsing", "printing", "clone-impls", "full", "extra-traits"]
 
 [build-dependencies]
-pyo3-build-config = { path = "../pyo3-build-config", version = "=0.25.0-dev" }
+pyo3-build-config = { path = "../pyo3-build-config", version = "=0.25.0" }
 
 [lints]
 workspace = true
diff --git a/pyo3-macros-backend/src/attributes.rs b/pyo3-macros-backend/src/attributes.rs
index 19a12801065..ac3894d6419 100644
--- a/pyo3-macros-backend/src/attributes.rs
+++ b/pyo3-macros-backend/src/attributes.rs
@@ -27,6 +27,7 @@ pub mod kw {
     syn::custom_keyword!(hash);
     syn::custom_keyword!(into_py_with);
     syn::custom_keyword!(item);
+    syn::custom_keyword!(immutable_type);
     syn::custom_keyword!(from_item_all);
     syn::custom_keyword!(mapping);
     syn::custom_keyword!(module);
@@ -45,6 +46,7 @@ pub mod kw {
     syn::custom_keyword!(transparent);
     syn::custom_keyword!(unsendable);
     syn::custom_keyword!(weakref);
+    syn::custom_keyword!(generic);
     syn::custom_keyword!(gil_used);
 }
 
@@ -350,37 +352,7 @@ impl<K: ToTokens, V: ToTokens> ToTokens for OptionalKeywordAttribute<K, V> {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct ExprPathWrap {
-    pub from_lit_str: bool,
-    pub expr_path: ExprPath,
-}
-
-impl Parse for ExprPathWrap {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        match input.parse::<ExprPath>() {
-            Ok(expr_path) => Ok(ExprPathWrap {
-                from_lit_str: false,
-                expr_path,
-            }),
-            Err(e) => match input.parse::<LitStrValue<ExprPath>>() {
-                Ok(LitStrValue(expr_path)) => Ok(ExprPathWrap {
-                    from_lit_str: true,
-                    expr_path,
-                }),
-                Err(_) => Err(e),
-            },
-        }
-    }
-}
-
-impl ToTokens for ExprPathWrap {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        self.expr_path.to_tokens(tokens)
-    }
-}
-
-pub type FromPyWithAttribute = KeywordAttribute<kw::from_py_with, ExprPathWrap>;
+pub type FromPyWithAttribute = KeywordAttribute<kw::from_py_with, ExprPath>;
 pub type IntoPyWithAttribute = KeywordAttribute<kw::into_py_with, ExprPath>;
 
 pub type DefaultAttribute = OptionalKeywordAttribute<Token![default], Expr>;
diff --git a/pyo3-macros-backend/src/derive_attributes.rs b/pyo3-macros-backend/src/derive_attributes.rs
new file mode 100644
index 00000000000..63328a107b4
--- /dev/null
+++ b/pyo3-macros-backend/src/derive_attributes.rs
@@ -0,0 +1,217 @@
+use crate::attributes::{
+    self, get_pyo3_options, CrateAttribute, DefaultAttribute, FromPyWithAttribute,
+    IntoPyWithAttribute, RenameAllAttribute,
+};
+use proc_macro2::Span;
+use syn::parse::{Parse, ParseStream};
+use syn::spanned::Spanned;
+use syn::{parenthesized, Attribute, LitStr, Result, Token};
+
+/// Attributes for deriving `FromPyObject`/`IntoPyObject` scoped on containers.
+pub enum ContainerAttribute {
+    /// Treat the Container as a Wrapper, operate directly on its field
+    Transparent(attributes::kw::transparent),
+    /// Force every field to be extracted from item of source Python object.
+    ItemAll(attributes::kw::from_item_all),
+    /// Change the name of an enum variant in the generated error message.
+    ErrorAnnotation(LitStr),
+    /// Change the path for the pyo3 crate
+    Crate(CrateAttribute),
+    /// Converts the field idents according to the [RenamingRule](attributes::RenamingRule) before extraction
+    RenameAll(RenameAllAttribute),
+}
+
+impl Parse for ContainerAttribute {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let lookahead = input.lookahead1();
+        if lookahead.peek(attributes::kw::transparent) {
+            let kw: attributes::kw::transparent = input.parse()?;
+            Ok(ContainerAttribute::Transparent(kw))
+        } else if lookahead.peek(attributes::kw::from_item_all) {
+            let kw: attributes::kw::from_item_all = input.parse()?;
+            Ok(ContainerAttribute::ItemAll(kw))
+        } else if lookahead.peek(attributes::kw::annotation) {
+            let _: attributes::kw::annotation = input.parse()?;
+            let _: Token![=] = input.parse()?;
+            input.parse().map(ContainerAttribute::ErrorAnnotation)
+        } else if lookahead.peek(Token![crate]) {
+            input.parse().map(ContainerAttribute::Crate)
+        } else if lookahead.peek(attributes::kw::rename_all) {
+            input.parse().map(ContainerAttribute::RenameAll)
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+#[derive(Default)]
+pub struct ContainerAttributes {
+    /// Treat the Container as a Wrapper, operate directly on its field
+    pub transparent: Option<attributes::kw::transparent>,
+    /// Force every field to be extracted from item of source Python object.
+    pub from_item_all: Option<attributes::kw::from_item_all>,
+    /// Change the name of an enum variant in the generated error message.
+    pub annotation: Option<syn::LitStr>,
+    /// Change the path for the pyo3 crate
+    pub krate: Option<CrateAttribute>,
+    /// Converts the field idents according to the [RenamingRule](attributes::RenamingRule) before extraction
+    pub rename_all: Option<RenameAllAttribute>,
+}
+
+impl ContainerAttributes {
+    pub fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
+        let mut options = ContainerAttributes::default();
+
+        for attr in attrs {
+            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
+                pyo3_attrs
+                    .into_iter()
+                    .try_for_each(|opt| options.set_option(opt))?;
+            }
+        }
+        Ok(options)
+    }
+
+    fn set_option(&mut self, option: ContainerAttribute) -> syn::Result<()> {
+        macro_rules! set_option {
+            ($key:ident) => {
+                {
+                    ensure_spanned!(
+                        self.$key.is_none(),
+                        $key.span() => concat!("`", stringify!($key), "` may only be specified once")
+                    );
+                    self.$key = Some($key);
+                }
+            };
+        }
+
+        match option {
+            ContainerAttribute::Transparent(transparent) => set_option!(transparent),
+            ContainerAttribute::ItemAll(from_item_all) => set_option!(from_item_all),
+            ContainerAttribute::ErrorAnnotation(annotation) => set_option!(annotation),
+            ContainerAttribute::Crate(krate) => set_option!(krate),
+            ContainerAttribute::RenameAll(rename_all) => set_option!(rename_all),
+        }
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum FieldGetter {
+    GetItem(attributes::kw::item, Option<syn::Lit>),
+    GetAttr(attributes::kw::attribute, Option<syn::LitStr>),
+}
+
+impl FieldGetter {
+    pub fn span(&self) -> Span {
+        match self {
+            FieldGetter::GetItem(item, _) => item.span,
+            FieldGetter::GetAttr(attribute, _) => attribute.span,
+        }
+    }
+}
+
+pub enum FieldAttribute {
+    Getter(FieldGetter),
+    FromPyWith(FromPyWithAttribute),
+    IntoPyWith(IntoPyWithAttribute),
+    Default(DefaultAttribute),
+}
+
+impl Parse for FieldAttribute {
+    fn parse(input: ParseStream<'_>) -> Result<Self> {
+        let lookahead = input.lookahead1();
+        if lookahead.peek(attributes::kw::attribute) {
+            let attr_kw: attributes::kw::attribute = input.parse()?;
+            if input.peek(syn::token::Paren) {
+                let content;
+                let _ = parenthesized!(content in input);
+                let attr_name: LitStr = content.parse()?;
+                if !content.is_empty() {
+                    return Err(content.error(
+                        "expected at most one argument: `attribute` or `attribute(\"name\")`",
+                    ));
+                }
+                ensure_spanned!(
+                    !attr_name.value().is_empty(),
+                    attr_name.span() => "attribute name cannot be empty"
+                );
+                Ok(Self::Getter(FieldGetter::GetAttr(attr_kw, Some(attr_name))))
+            } else {
+                Ok(Self::Getter(FieldGetter::GetAttr(attr_kw, None)))
+            }
+        } else if lookahead.peek(attributes::kw::item) {
+            let item_kw: attributes::kw::item = input.parse()?;
+            if input.peek(syn::token::Paren) {
+                let content;
+                let _ = parenthesized!(content in input);
+                let key = content.parse()?;
+                if !content.is_empty() {
+                    return Err(
+                        content.error("expected at most one argument: `item` or `item(key)`")
+                    );
+                }
+                Ok(Self::Getter(FieldGetter::GetItem(item_kw, Some(key))))
+            } else {
+                Ok(Self::Getter(FieldGetter::GetItem(item_kw, None)))
+            }
+        } else if lookahead.peek(attributes::kw::from_py_with) {
+            input.parse().map(Self::FromPyWith)
+        } else if lookahead.peek(attributes::kw::into_py_with) {
+            input.parse().map(FieldAttribute::IntoPyWith)
+        } else if lookahead.peek(Token![default]) {
+            input.parse().map(Self::Default)
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct FieldAttributes {
+    pub getter: Option<FieldGetter>,
+    pub from_py_with: Option<FromPyWithAttribute>,
+    pub into_py_with: Option<IntoPyWithAttribute>,
+    pub default: Option<DefaultAttribute>,
+}
+
+impl FieldAttributes {
+    /// Extract the field attributes.
+    pub fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
+        let mut options = FieldAttributes::default();
+
+        for attr in attrs {
+            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
+                pyo3_attrs
+                    .into_iter()
+                    .try_for_each(|opt| options.set_option(opt))?;
+            }
+        }
+        Ok(options)
+    }
+
+    fn set_option(&mut self, option: FieldAttribute) -> syn::Result<()> {
+        macro_rules! set_option {
+            ($key:ident) => {
+                set_option!($key, concat!("`", stringify!($key), "` may only be specified once"))
+            };
+            ($key:ident, $msg: expr) => {{
+                ensure_spanned!(
+                    self.$key.is_none(),
+                    $key.span() => $msg
+                );
+                self.$key = Some($key);
+            }}
+        }
+
+        match option {
+            FieldAttribute::Getter(getter) => {
+                set_option!(getter, "only one of `attribute` or `item` can be provided")
+            }
+            FieldAttribute::FromPyWith(from_py_with) => set_option!(from_py_with),
+            FieldAttribute::IntoPyWith(into_py_with) => set_option!(into_py_with),
+            FieldAttribute::Default(default) => set_option!(default),
+        }
+        Ok(())
+    }
+}
diff --git a/pyo3-macros-backend/src/frompyobject.rs b/pyo3-macros-backend/src/frompyobject.rs
index 68f95e794a8..2c288709f93 100644
--- a/pyo3-macros-backend/src/frompyobject.rs
+++ b/pyo3-macros-backend/src/frompyobject.rs
@@ -1,18 +1,11 @@
-use crate::attributes::{
-    self, get_pyo3_options, CrateAttribute, DefaultAttribute, FromPyWithAttribute,
-    RenameAllAttribute, RenamingRule,
-};
-use crate::utils::{self, deprecated_from_py_with, Ctx};
+use crate::attributes::{DefaultAttribute, FromPyWithAttribute, RenamingRule};
+use crate::derive_attributes::{ContainerAttributes, FieldAttributes, FieldGetter};
+use crate::utils::{self, Ctx};
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use syn::{
-    ext::IdentExt,
-    parenthesized,
-    parse::{Parse, ParseStream},
-    parse_quote,
-    punctuated::Punctuated,
-    spanned::Spanned,
-    Attribute, DataEnum, DeriveInput, Fields, Ident, LitStr, Result, Token,
+    ext::IdentExt, parse_quote, punctuated::Punctuated, spanned::Spanned, DataEnum, DeriveInput,
+    Fields, Ident, Result, Token,
 };
 
 /// Describes derivation input of an enum.
@@ -26,7 +19,11 @@ impl<'a> Enum<'a> {
     ///
     /// `data_enum` is the `syn` representation of the input enum, `ident` is the
     /// `Identifier` of the enum.
-    fn new(data_enum: &'a DataEnum, ident: &'a Ident, options: ContainerOptions) -> Result<Self> {
+    fn new(
+        data_enum: &'a DataEnum,
+        ident: &'a Ident,
+        options: ContainerAttributes,
+    ) -> Result<Self> {
         ensure_spanned!(
             !data_enum.variants.is_empty(),
             ident.span() => "cannot derive FromPyObject for empty enum"
@@ -35,7 +32,7 @@ impl<'a> Enum<'a> {
             .variants
             .iter()
             .map(|variant| {
-                let mut variant_options = ContainerOptions::from_attrs(&variant.attrs)?;
+                let mut variant_options = ContainerAttributes::from_attrs(&variant.attrs)?;
                 if let Some(rename_all) = &options.rename_all {
                     ensure_spanned!(
                         variant_options.rename_all.is_none(),
@@ -149,7 +146,7 @@ impl<'a> Container<'a> {
     /// Construct a container based on fields, identifier and attributes.
     ///
     /// Fails if the variant has no fields or incompatible attributes.
-    fn new(fields: &'a Fields, path: syn::Path, options: ContainerOptions) -> Result<Self> {
+    fn new(fields: &'a Fields, path: syn::Path, options: ContainerAttributes) -> Result<Self> {
         let style = match fields {
             Fields::Unnamed(unnamed) if !unnamed.unnamed.is_empty() => {
                 ensure_spanned!(
@@ -160,7 +157,7 @@ impl<'a> Container<'a> {
                     .unnamed
                     .iter()
                     .map(|field| {
-                        let attrs = FieldPyO3Attributes::from_attrs(&field.attrs)?;
+                        let attrs = FieldAttributes::from_attrs(&field.attrs)?;
                         ensure_spanned!(
                             attrs.getter.is_none(),
                             field.span() => "`getter` is not permitted on tuple struct elements."
@@ -180,7 +177,7 @@ impl<'a> Container<'a> {
                     // explicit annotation.
                     let field = tuple_fields.pop().unwrap();
                     ContainerType::TupleNewtype(field.from_py_with)
-                } else if options.transparent {
+                } else if options.transparent.is_some() {
                     bail_spanned!(
                         fields.span() => "transparent structs and variants can only have 1 field"
                     );
@@ -197,17 +194,17 @@ impl<'a> Container<'a> {
                             .ident
                             .as_ref()
                             .expect("Named fields should have identifiers");
-                        let mut attrs = FieldPyO3Attributes::from_attrs(&field.attrs)?;
+                        let mut attrs = FieldAttributes::from_attrs(&field.attrs)?;
 
                         if let Some(ref from_item_all) = options.from_item_all {
-                            if let Some(replaced) = attrs.getter.replace(FieldGetter::GetItem(None))
+                            if let Some(replaced) = attrs.getter.replace(FieldGetter::GetItem(parse_quote!(item), None))
                             {
                                 match replaced {
-                                    FieldGetter::GetItem(Some(item_name)) => {
-                                        attrs.getter = Some(FieldGetter::GetItem(Some(item_name)));
+                                    FieldGetter::GetItem(item, Some(item_name)) => {
+                                        attrs.getter = Some(FieldGetter::GetItem(item, Some(item_name)));
                                     }
-                                    FieldGetter::GetItem(None) => bail_spanned!(from_item_all.span() => "Useless `item` - the struct is already annotated with `from_item_all`"),
-                                    FieldGetter::GetAttr(_) => bail_spanned!(
+                                    FieldGetter::GetItem(_, None) => bail_spanned!(from_item_all.span() => "Useless `item` - the struct is already annotated with `from_item_all`"),
+                                    FieldGetter::GetAttr(_, _) => bail_spanned!(
                                         from_item_all.span() => "The struct is already annotated with `from_item_all`, `attribute` is not allowed"
                                     ),
                                 }
@@ -226,7 +223,7 @@ impl<'a> Container<'a> {
                     bail_spanned!(
                         fields.span() => "cannot derive FromPyObject for structs and variants with only default values"
                     )
-                } else if options.transparent {
+                } else if options.transparent.is_some() {
                     ensure_spanned!(
                         struct_fields.len() == 1,
                         fields.span() => "transparent structs and variants can only have 1 field"
@@ -304,13 +301,10 @@ impl<'a> Container<'a> {
                 value: expr_path,
             }) = from_py_with
             {
-                let deprecation = deprecated_from_py_with(expr_path).unwrap_or_default();
-
                 let extractor = quote_spanned! { kw.span =>
                     { let from_py_with: fn(_) -> _ = #expr_path; from_py_with }
                 };
                 quote! {
-                    #deprecation
                     Ok(#self_ty {
                         #ident: #pyo3_path::impl_::frompyobject::extract_struct_field_with(#extractor, obj, #struct_name, #field_name)?
                     })
@@ -327,13 +321,10 @@ impl<'a> Container<'a> {
             value: expr_path,
         }) = from_py_with
         {
-            let deprecation = deprecated_from_py_with(expr_path).unwrap_or_default();
-
             let extractor = quote_spanned! { kw.span =>
                 { let from_py_with: fn(_) -> _ = #expr_path; from_py_with }
             };
             quote! {
-                #deprecation
                 #pyo3_path::impl_::frompyobject::extract_tuple_struct_field_with(#extractor, obj, #struct_name, 0).map(#self_ty)
             }
         } else {
@@ -367,14 +358,7 @@ impl<'a> Container<'a> {
             }}
         });
 
-        let deprecations = struct_fields
-            .iter()
-            .filter_map(|fields| fields.from_py_with.as_ref())
-            .filter_map(|kw| deprecated_from_py_with(&kw.value))
-            .collect::<TokenStream>();
-
         quote!(
-            #deprecations
             match #pyo3_path::types::PyAnyMethods::extract(obj) {
                 ::std::result::Result::Ok((#(#field_idents),*)) => ::std::result::Result::Ok(#self_ty(#(#fields),*)),
                 ::std::result::Result::Err(err) => ::std::result::Result::Err(err),
@@ -390,24 +374,28 @@ impl<'a> Container<'a> {
         for field in struct_fields {
             let ident = field.ident;
             let field_name = ident.unraw().to_string();
-            let getter = match field.getter.as_ref().unwrap_or(&FieldGetter::GetAttr(None)) {
-                FieldGetter::GetAttr(Some(name)) => {
+            let getter = match field
+                .getter
+                .as_ref()
+                .unwrap_or(&FieldGetter::GetAttr(parse_quote!(attribute), None))
+            {
+                FieldGetter::GetAttr(_, Some(name)) => {
                     quote!(#pyo3_path::types::PyAnyMethods::getattr(obj, #pyo3_path::intern!(obj.py(), #name)))
                 }
-                FieldGetter::GetAttr(None) => {
+                FieldGetter::GetAttr(_, None) => {
                     let name = self
                         .rename_rule
                         .map(|rule| utils::apply_renaming_rule(rule, &field_name));
                     let name = name.as_deref().unwrap_or(&field_name);
                     quote!(#pyo3_path::types::PyAnyMethods::getattr(obj, #pyo3_path::intern!(obj.py(), #name)))
                 }
-                FieldGetter::GetItem(Some(syn::Lit::Str(key))) => {
+                FieldGetter::GetItem(_, Some(syn::Lit::Str(key))) => {
                     quote!(#pyo3_path::types::PyAnyMethods::get_item(obj, #pyo3_path::intern!(obj.py(), #key)))
                 }
-                FieldGetter::GetItem(Some(key)) => {
+                FieldGetter::GetItem(_, Some(key)) => {
                     quote!(#pyo3_path::types::PyAnyMethods::get_item(obj, #key))
                 }
-                FieldGetter::GetItem(None) => {
+                FieldGetter::GetItem(_, None) => {
                     let name = self
                         .rename_rule
                         .map(|rule| utils::apply_renaming_rule(rule, &field_name));
@@ -448,229 +436,7 @@ impl<'a> Container<'a> {
             fields.push(quote!(#ident: #extracted));
         }
 
-        let d = struct_fields
-            .iter()
-            .filter_map(|field| field.from_py_with.as_ref())
-            .filter_map(|kw| deprecated_from_py_with(&kw.value))
-            .collect::<TokenStream>();
-
-        quote!(#d ::std::result::Result::Ok(#self_ty{#fields}))
-    }
-}
-
-#[derive(Default)]
-struct ContainerOptions {
-    /// Treat the Container as a Wrapper, directly extract its fields from the input object.
-    transparent: bool,
-    /// Force every field to be extracted from item of source Python object.
-    from_item_all: Option<attributes::kw::from_item_all>,
-    /// Change the name of an enum variant in the generated error message.
-    annotation: Option<syn::LitStr>,
-    /// Change the path for the pyo3 crate
-    krate: Option<CrateAttribute>,
-    /// Converts the field idents according to the [RenamingRule] before extraction
-    rename_all: Option<RenameAllAttribute>,
-}
-
-/// Attributes for deriving FromPyObject scoped on containers.
-enum ContainerPyO3Attribute {
-    /// Treat the Container as a Wrapper, directly extract its fields from the input object.
-    Transparent(attributes::kw::transparent),
-    /// Force every field to be extracted from item of source Python object.
-    ItemAll(attributes::kw::from_item_all),
-    /// Change the name of an enum variant in the generated error message.
-    ErrorAnnotation(LitStr),
-    /// Change the path for the pyo3 crate
-    Crate(CrateAttribute),
-    /// Converts the field idents according to the [RenamingRule] before extraction
-    RenameAll(RenameAllAttribute),
-}
-
-impl Parse for ContainerPyO3Attribute {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let lookahead = input.lookahead1();
-        if lookahead.peek(attributes::kw::transparent) {
-            let kw: attributes::kw::transparent = input.parse()?;
-            Ok(ContainerPyO3Attribute::Transparent(kw))
-        } else if lookahead.peek(attributes::kw::from_item_all) {
-            let kw: attributes::kw::from_item_all = input.parse()?;
-            Ok(ContainerPyO3Attribute::ItemAll(kw))
-        } else if lookahead.peek(attributes::kw::annotation) {
-            let _: attributes::kw::annotation = input.parse()?;
-            let _: Token![=] = input.parse()?;
-            input.parse().map(ContainerPyO3Attribute::ErrorAnnotation)
-        } else if lookahead.peek(Token![crate]) {
-            input.parse().map(ContainerPyO3Attribute::Crate)
-        } else if lookahead.peek(attributes::kw::rename_all) {
-            input.parse().map(ContainerPyO3Attribute::RenameAll)
-        } else {
-            Err(lookahead.error())
-        }
-    }
-}
-
-impl ContainerOptions {
-    fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
-        let mut options = ContainerOptions::default();
-
-        for attr in attrs {
-            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
-                for pyo3_attr in pyo3_attrs {
-                    match pyo3_attr {
-                        ContainerPyO3Attribute::Transparent(kw) => {
-                            ensure_spanned!(
-                                !options.transparent,
-                                kw.span() => "`transparent` may only be provided once"
-                            );
-                            options.transparent = true;
-                        }
-                        ContainerPyO3Attribute::ItemAll(kw) => {
-                            ensure_spanned!(
-                                options.from_item_all.is_none(),
-                                kw.span() => "`from_item_all` may only be provided once"
-                            );
-                            options.from_item_all = Some(kw);
-                        }
-                        ContainerPyO3Attribute::ErrorAnnotation(lit_str) => {
-                            ensure_spanned!(
-                                options.annotation.is_none(),
-                                lit_str.span() => "`annotation` may only be provided once"
-                            );
-                            options.annotation = Some(lit_str);
-                        }
-                        ContainerPyO3Attribute::Crate(path) => {
-                            ensure_spanned!(
-                                options.krate.is_none(),
-                                path.span() => "`crate` may only be provided once"
-                            );
-                            options.krate = Some(path);
-                        }
-                        ContainerPyO3Attribute::RenameAll(rename_all) => {
-                            ensure_spanned!(
-                                options.rename_all.is_none(),
-                                rename_all.span() => "`rename_all` may only be provided once"
-                            );
-                            options.rename_all = Some(rename_all);
-                        }
-                    }
-                }
-            }
-        }
-        Ok(options)
-    }
-}
-
-/// Attributes for deriving FromPyObject scoped on fields.
-#[derive(Clone, Debug)]
-struct FieldPyO3Attributes {
-    getter: Option<FieldGetter>,
-    from_py_with: Option<FromPyWithAttribute>,
-    default: Option<DefaultAttribute>,
-}
-
-#[derive(Clone, Debug)]
-enum FieldGetter {
-    GetItem(Option<syn::Lit>),
-    GetAttr(Option<LitStr>),
-}
-
-enum FieldPyO3Attribute {
-    Getter(FieldGetter),
-    FromPyWith(FromPyWithAttribute),
-    Default(DefaultAttribute),
-}
-
-impl Parse for FieldPyO3Attribute {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let lookahead = input.lookahead1();
-        if lookahead.peek(attributes::kw::attribute) {
-            let _: attributes::kw::attribute = input.parse()?;
-            if input.peek(syn::token::Paren) {
-                let content;
-                let _ = parenthesized!(content in input);
-                let attr_name: LitStr = content.parse()?;
-                if !content.is_empty() {
-                    return Err(content.error(
-                        "expected at most one argument: `attribute` or `attribute(\"name\")`",
-                    ));
-                }
-                ensure_spanned!(
-                    !attr_name.value().is_empty(),
-                    attr_name.span() => "attribute name cannot be empty"
-                );
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetAttr(Some(
-                    attr_name,
-                ))))
-            } else {
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetAttr(None)))
-            }
-        } else if lookahead.peek(attributes::kw::item) {
-            let _: attributes::kw::item = input.parse()?;
-            if input.peek(syn::token::Paren) {
-                let content;
-                let _ = parenthesized!(content in input);
-                let key = content.parse()?;
-                if !content.is_empty() {
-                    return Err(
-                        content.error("expected at most one argument: `item` or `item(key)`")
-                    );
-                }
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetItem(Some(key))))
-            } else {
-                Ok(FieldPyO3Attribute::Getter(FieldGetter::GetItem(None)))
-            }
-        } else if lookahead.peek(attributes::kw::from_py_with) {
-            input.parse().map(FieldPyO3Attribute::FromPyWith)
-        } else if lookahead.peek(Token![default]) {
-            input.parse().map(FieldPyO3Attribute::Default)
-        } else {
-            Err(lookahead.error())
-        }
-    }
-}
-
-impl FieldPyO3Attributes {
-    /// Extract the field attributes.
-    fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
-        let mut getter = None;
-        let mut from_py_with = None;
-        let mut default = None;
-
-        for attr in attrs {
-            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
-                for pyo3_attr in pyo3_attrs {
-                    match pyo3_attr {
-                        FieldPyO3Attribute::Getter(field_getter) => {
-                            ensure_spanned!(
-                                getter.is_none(),
-                                attr.span() => "only one of `attribute` or `item` can be provided"
-                            );
-                            getter = Some(field_getter);
-                        }
-                        FieldPyO3Attribute::FromPyWith(from_py_with_attr) => {
-                            ensure_spanned!(
-                                from_py_with.is_none(),
-                                attr.span() => "`from_py_with` may only be provided once"
-                            );
-                            from_py_with = Some(from_py_with_attr);
-                        }
-                        FieldPyO3Attribute::Default(default_attr) => {
-                            ensure_spanned!(
-                                default.is_none(),
-                                attr.span() => "`default` may only be provided once"
-                            );
-                            default = Some(default_attr);
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(FieldPyO3Attributes {
-            getter,
-            from_py_with,
-            default,
-        })
+        quote!(::std::result::Result::Ok(#self_ty{#fields}))
     }
 }
 
@@ -693,7 +459,7 @@ fn verify_and_get_lifetime(generics: &syn::Generics) -> Result<Option<&syn::Life
 ///   * Derivation for structs with generic fields like `struct<T> Foo(T)`
 ///     adds `T: FromPyObject` on the derived implementation.
 pub fn build_derive_from_pyobject(tokens: &DeriveInput) -> Result<TokenStream> {
-    let options = ContainerOptions::from_attrs(&tokens.attrs)?;
+    let options = ContainerAttributes::from_attrs(&tokens.attrs)?;
     let ctx = &Ctx::new(&options.krate, None);
     let Ctx { pyo3_path, .. } = &ctx;
 
@@ -717,7 +483,7 @@ pub fn build_derive_from_pyobject(tokens: &DeriveInput) -> Result<TokenStream> {
 
     let derives = match &tokens.data {
         syn::Data::Enum(en) => {
-            if options.transparent || options.annotation.is_some() {
+            if options.transparent.is_some() || options.annotation.is_some() {
                 bail_spanned!(tokens.span() => "`transparent` or `annotation` is not supported \
                                                 at top level for enums");
             }
diff --git a/pyo3-macros-backend/src/intopyobject.rs b/pyo3-macros-backend/src/intopyobject.rs
index 787d1dd6259..2532812f6e1 100644
--- a/pyo3-macros-backend/src/intopyobject.rs
+++ b/pyo3-macros-backend/src/intopyobject.rs
@@ -1,173 +1,13 @@
-use crate::attributes::{self, get_pyo3_options, CrateAttribute, IntoPyWithAttribute};
-use crate::utils::Ctx;
+use crate::attributes::{IntoPyWithAttribute, RenamingRule};
+use crate::derive_attributes::{ContainerAttributes, FieldAttributes};
+use crate::utils::{self, Ctx};
 use proc_macro2::{Span, TokenStream};
-use quote::{format_ident, quote, quote_spanned};
+use quote::{format_ident, quote, quote_spanned, ToTokens};
 use syn::ext::IdentExt;
-use syn::parse::{Parse, ParseStream};
 use syn::spanned::Spanned as _;
-use syn::{
-    parenthesized, parse_quote, Attribute, DataEnum, DeriveInput, Fields, Ident, Index, Result,
-    Token,
-};
-
-/// Attributes for deriving `IntoPyObject` scoped on containers.
-enum ContainerPyO3Attribute {
-    /// Treat the Container as a Wrapper, directly convert its field into the output object.
-    Transparent(attributes::kw::transparent),
-    /// Change the path for the pyo3 crate
-    Crate(CrateAttribute),
-}
-
-impl Parse for ContainerPyO3Attribute {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let lookahead = input.lookahead1();
-        if lookahead.peek(attributes::kw::transparent) {
-            let kw: attributes::kw::transparent = input.parse()?;
-            Ok(ContainerPyO3Attribute::Transparent(kw))
-        } else if lookahead.peek(Token![crate]) {
-            input.parse().map(ContainerPyO3Attribute::Crate)
-        } else {
-            Err(lookahead.error())
-        }
-    }
-}
-
-#[derive(Default)]
-struct ContainerOptions {
-    /// Treat the Container as a Wrapper, directly convert its field into the output object.
-    transparent: Option<attributes::kw::transparent>,
-    /// Change the path for the pyo3 crate
-    krate: Option<CrateAttribute>,
-}
-
-impl ContainerOptions {
-    fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
-        let mut options = ContainerOptions::default();
-
-        for attr in attrs {
-            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
-                pyo3_attrs
-                    .into_iter()
-                    .try_for_each(|opt| options.set_option(opt))?;
-            }
-        }
-        Ok(options)
-    }
-
-    fn set_option(&mut self, option: ContainerPyO3Attribute) -> syn::Result<()> {
-        macro_rules! set_option {
-            ($key:ident) => {
-                {
-                    ensure_spanned!(
-                        self.$key.is_none(),
-                        $key.span() => concat!("`", stringify!($key), "` may only be specified once")
-                    );
-                    self.$key = Some($key);
-                }
-            };
-        }
-
-        match option {
-            ContainerPyO3Attribute::Transparent(transparent) => set_option!(transparent),
-            ContainerPyO3Attribute::Crate(krate) => set_option!(krate),
-        }
-        Ok(())
-    }
-}
-
-#[derive(Debug, Clone)]
-struct ItemOption {
-    field: Option<syn::LitStr>,
-    span: Span,
-}
-
-impl ItemOption {
-    fn span(&self) -> Span {
-        self.span
-    }
-}
-
-enum FieldAttribute {
-    Item(ItemOption),
-    IntoPyWith(IntoPyWithAttribute),
-}
-
-impl Parse for FieldAttribute {
-    fn parse(input: ParseStream<'_>) -> Result<Self> {
-        let lookahead = input.lookahead1();
-        if lookahead.peek(attributes::kw::attribute) {
-            let attr: attributes::kw::attribute = input.parse()?;
-            bail_spanned!(attr.span => "`attribute` is not supported by `IntoPyObject`");
-        } else if lookahead.peek(attributes::kw::item) {
-            let attr: attributes::kw::item = input.parse()?;
-            if input.peek(syn::token::Paren) {
-                let content;
-                let _ = parenthesized!(content in input);
-                let key = content.parse()?;
-                if !content.is_empty() {
-                    return Err(
-                        content.error("expected at most one argument: `item` or `item(key)`")
-                    );
-                }
-                Ok(FieldAttribute::Item(ItemOption {
-                    field: Some(key),
-                    span: attr.span,
-                }))
-            } else {
-                Ok(FieldAttribute::Item(ItemOption {
-                    field: None,
-                    span: attr.span,
-                }))
-            }
-        } else if lookahead.peek(attributes::kw::into_py_with) {
-            input.parse().map(FieldAttribute::IntoPyWith)
-        } else {
-            Err(lookahead.error())
-        }
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-struct FieldAttributes {
-    item: Option<ItemOption>,
-    into_py_with: Option<IntoPyWithAttribute>,
-}
-
-impl FieldAttributes {
-    /// Extract the field attributes.
-    fn from_attrs(attrs: &[Attribute]) -> Result<Self> {
-        let mut options = FieldAttributes::default();
-
-        for attr in attrs {
-            if let Some(pyo3_attrs) = get_pyo3_options(attr)? {
-                pyo3_attrs
-                    .into_iter()
-                    .try_for_each(|opt| options.set_option(opt))?;
-            }
-        }
-        Ok(options)
-    }
+use syn::{parse_quote, DataEnum, DeriveInput, Fields, Ident, Index, Result};
 
-    fn set_option(&mut self, option: FieldAttribute) -> syn::Result<()> {
-        macro_rules! set_option {
-            ($key:ident) => {
-                {
-                    ensure_spanned!(
-                        self.$key.is_none(),
-                        $key.span() => concat!("`", stringify!($key), "` may only be specified once")
-                    );
-                    self.$key = Some($key);
-                }
-            };
-        }
-
-        match option {
-            FieldAttribute::Item(item) => set_option!(item),
-            FieldAttribute::IntoPyWith(into_py_with) => set_option!(into_py_with),
-        }
-        Ok(())
-    }
-}
+struct ItemOption(Option<syn::Lit>);
 
 enum IntoPyObjectTypes {
     Transparent(syn::Type),
@@ -225,6 +65,7 @@ struct Container<'a, const REF: bool> {
     path: syn::Path,
     receiver: Option<Ident>,
     ty: ContainerType<'a>,
+    rename_rule: Option<RenamingRule>,
 }
 
 /// Construct a container based on fields, identifier and attributes.
@@ -235,18 +76,22 @@ impl<'a, const REF: bool> Container<'a, REF> {
         receiver: Option<Ident>,
         fields: &'a Fields,
         path: syn::Path,
-        options: ContainerOptions,
+        options: ContainerAttributes,
     ) -> Result<Self> {
         let style = match fields {
             Fields::Unnamed(unnamed) if !unnamed.unnamed.is_empty() => {
+                ensure_spanned!(
+                    options.rename_all.is_none(),
+                    options.rename_all.span() => "`rename_all` is useless on tuple structs and variants."
+                );
                 let mut tuple_fields = unnamed
                     .unnamed
                     .iter()
                     .map(|field| {
                         let attrs = FieldAttributes::from_attrs(&field.attrs)?;
                         ensure_spanned!(
-                            attrs.item.is_none(),
-                            attrs.item.unwrap().span() => "`item` is not permitted on tuple struct elements."
+                            attrs.getter.is_none(),
+                            attrs.getter.unwrap().span() => "`item` and `attribute` are not permitted on tuple struct elements."
                         );
                         Ok(TupleStructField {
                             field,
@@ -284,8 +129,12 @@ impl<'a, const REF: bool> Container<'a, REF> {
                     let field = named.named.iter().next().unwrap();
                     let attrs = FieldAttributes::from_attrs(&field.attrs)?;
                     ensure_spanned!(
-                        attrs.item.is_none(),
-                        attrs.item.unwrap().span() => "`transparent` structs may not have `item` for the inner field"
+                        attrs.getter.is_none(),
+                        attrs.getter.unwrap().span() => "`transparent` structs may not have `item` nor `attribute` for the inner field"
+                    );
+                    ensure_spanned!(
+                        options.rename_all.is_none(),
+                        options.rename_all.span() => "`rename_all` is not permitted on `transparent` structs and variants"
                     );
                     ensure_spanned!(
                         attrs.into_py_with.is_none(),
@@ -307,7 +156,12 @@ impl<'a, const REF: bool> Container<'a, REF> {
                             Ok(NamedStructField {
                                 ident,
                                 field,
-                                item: attrs.item,
+                                item: attrs.getter.and_then(|getter| match getter {
+                                    crate::derive_attributes::FieldGetter::GetItem(_, lit) => {
+                                        Some(ItemOption(lit))
+                                    }
+                                    crate::derive_attributes::FieldGetter::GetAttr(_, _) => None,
+                                }),
                                 into_py_with: attrs.into_py_with,
                             })
                         })
@@ -324,6 +178,7 @@ impl<'a, const REF: bool> Container<'a, REF> {
             path,
             receiver,
             ty: style,
+            rename_rule: options.rename_all.map(|v| v.value.rule),
         };
         Ok(v)
     }
@@ -407,9 +262,12 @@ impl<'a, const REF: bool> Container<'a, REF> {
                 let key = f
                     .item
                     .as_ref()
-                    .and_then(|item| item.field.as_ref())
-                    .map(|item| item.value())
-                    .unwrap_or_else(|| f.ident.unraw().to_string());
+                    .and_then(|item| item.0.as_ref())
+                    .map(|item| item.into_token_stream())
+                    .unwrap_or_else(|| {
+                        let name = f.ident.unraw().to_string();
+                        self.rename_rule.map(|rule| utils::apply_renaming_rule(rule, &name)).unwrap_or(name).into_token_stream()
+                    });
                 let value = Ident::new(&format!("arg{i}"), f.field.ty.span());
 
                 if let Some(expr_path) = f.into_py_with.as_ref().map(|i|&i.value) {
@@ -519,7 +377,7 @@ impl<'a, const REF: bool> Enum<'a, REF> {
             .variants
             .iter()
             .map(|variant| {
-                let attrs = ContainerOptions::from_attrs(&variant.attrs)?;
+                let attrs = ContainerAttributes::from_attrs(&variant.attrs)?;
                 let var_ident = &variant.ident;
 
                 ensure_spanned!(
@@ -582,7 +440,7 @@ fn verify_and_get_lifetime(generics: &syn::Generics) -> Option<&syn::LifetimePar
 }
 
 pub fn build_derive_into_pyobject<const REF: bool>(tokens: &DeriveInput) -> Result<TokenStream> {
-    let options = ContainerOptions::from_attrs(&tokens.attrs)?;
+    let options = ContainerAttributes::from_attrs(&tokens.attrs)?;
     let ctx = &Ctx::new(&options.krate, None);
     let Ctx { pyo3_path, .. } = &ctx;
 
@@ -614,6 +472,9 @@ pub fn build_derive_into_pyobject<const REF: bool>(tokens: &DeriveInput) -> Resu
             if options.transparent.is_some() {
                 bail_spanned!(tokens.span() => "`transparent` is not supported at top level for enums");
             }
+            if let Some(rename_all) = options.rename_all {
+                bail_spanned!(rename_all.span() => "`rename_all` is not supported at top level for enums");
+            }
             let en = Enum::<REF>::new(en, &tokens.ident)?;
             en.build(ctx)
         }
diff --git a/pyo3-macros-backend/src/introspection.rs b/pyo3-macros-backend/src/introspection.rs
index 17ae19ee8d9..303e952b814 100644
--- a/pyo3-macros-backend/src/introspection.rs
+++ b/pyo3-macros-backend/src/introspection.rs
@@ -8,15 +8,18 @@
 //! The JSON blobs format must be synchronized with the `pyo3_introspection::introspection.rs::Chunk`
 //! type that is used to parse them.
 
+use crate::method::{FnArg, RegularArg};
+use crate::pyfunction::FunctionSignature;
 use crate::utils::PyO3CratePath;
 use proc_macro2::{Span, TokenStream};
 use quote::{format_ident, quote, ToTokens};
+use std::borrow::Cow;
 use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::mem::take;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use syn::{Attribute, Ident};
+use syn::{Attribute, Ident, Type, TypePath};
 
 static GLOBAL_COUNTER_FOR_UNIQUE_NAMES: AtomicUsize = AtomicUsize::new(0);
 
@@ -26,11 +29,11 @@ pub fn module_introspection_code<'a>(
     members: impl IntoIterator<Item = &'a Ident>,
     members_cfg_attrs: impl IntoIterator<Item = &'a Vec<Attribute>>,
 ) -> TokenStream {
-    let stub = IntrospectionNode::Map(
+    IntrospectionNode::Map(
         [
-            ("type", IntrospectionNode::String("module")),
+            ("type", IntrospectionNode::String("module".into())),
             ("id", IntrospectionNode::IntrospectionId(None)),
-            ("name", IntrospectionNode::String(name)),
+            ("name", IntrospectionNode::String(name.into())),
             (
                 "members",
                 IntrospectionNode::List(
@@ -39,7 +42,9 @@ pub fn module_introspection_code<'a>(
                         .zip(members_cfg_attrs)
                         .filter_map(|(member, attributes)| {
                             if attributes.is_empty() {
-                                Some(IntrospectionNode::IntrospectionId(Some(member)))
+                                Some(IntrospectionNode::IntrospectionId(Some(ident_to_type(
+                                    member,
+                                ))))
                             } else {
                                 None // TODO: properly interpret cfg attributes
                             }
@@ -50,12 +55,7 @@ pub fn module_introspection_code<'a>(
         ]
         .into(),
     )
-    .emit(pyo3_crate_path);
-    let introspection_id = introspection_id_const();
-    quote! {
-        #stub
-        #introspection_id
-    }
+    .emit(pyo3_crate_path)
 }
 
 pub fn class_introspection_code(
@@ -63,44 +63,163 @@ pub fn class_introspection_code(
     ident: &Ident,
     name: &str,
 ) -> TokenStream {
-    let stub = IntrospectionNode::Map(
+    IntrospectionNode::Map(
         [
-            ("type", IntrospectionNode::String("class")),
-            ("id", IntrospectionNode::IntrospectionId(Some(ident))),
-            ("name", IntrospectionNode::String(name)),
+            ("type", IntrospectionNode::String("class".into())),
+            (
+                "id",
+                IntrospectionNode::IntrospectionId(Some(ident_to_type(ident))),
+            ),
+            ("name", IntrospectionNode::String(name.into())),
         ]
         .into(),
     )
-    .emit(pyo3_crate_path);
-    let introspection_id = introspection_id_const();
-    quote! {
-        #stub
-        impl #ident {
-            #introspection_id
+    .emit(pyo3_crate_path)
+}
+
+pub fn function_introspection_code(
+    pyo3_crate_path: &PyO3CratePath,
+    ident: Option<&Ident>,
+    name: &str,
+    signature: &FunctionSignature<'_>,
+    first_argument: Option<&'static str>,
+    decorators: impl IntoIterator<Item = String>,
+    parent: Option<&Type>,
+) -> TokenStream {
+    let mut desc = HashMap::from([
+        ("type", IntrospectionNode::String("function".into())),
+        ("name", IntrospectionNode::String(name.into())),
+        (
+            "arguments",
+            arguments_introspection_data(signature, first_argument),
+        ),
+    ]);
+    if let Some(ident) = ident {
+        desc.insert(
+            "id",
+            IntrospectionNode::IntrospectionId(Some(ident_to_type(ident))),
+        );
+    }
+    let decorators = decorators
+        .into_iter()
+        .map(|d| IntrospectionNode::String(d.into()))
+        .collect::<Vec<_>>();
+    if !decorators.is_empty() {
+        desc.insert("decorators", IntrospectionNode::List(decorators));
+    }
+    if let Some(parent) = parent {
+        desc.insert(
+            "parent",
+            IntrospectionNode::IntrospectionId(Some(Cow::Borrowed(parent))),
+        );
+    }
+    IntrospectionNode::Map(desc).emit(pyo3_crate_path)
+}
+
+fn arguments_introspection_data<'a>(
+    signature: &'a FunctionSignature<'a>,
+    first_argument: Option<&'a str>,
+) -> IntrospectionNode<'a> {
+    let mut argument_desc = signature.arguments.iter().filter_map(|arg| {
+        if let FnArg::Regular(arg) = arg {
+            Some(arg)
+        } else {
+            None
         }
+    });
+
+    let mut posonlyargs = Vec::new();
+    let mut args = Vec::new();
+    let mut vararg = None;
+    let mut kwonlyargs = Vec::new();
+    let mut kwarg = None;
+
+    if let Some(first_argument) = first_argument {
+        posonlyargs.push(IntrospectionNode::Map(
+            [("name", IntrospectionNode::String(first_argument.into()))].into(),
+        ));
+    }
+
+    for (i, param) in signature
+        .python_signature
+        .positional_parameters
+        .iter()
+        .enumerate()
+    {
+        let arg_desc = if let Some(arg_desc) = argument_desc.next() {
+            arg_desc
+        } else {
+            panic!("Less arguments than in python signature");
+        };
+        let arg = argument_introspection_data(param, arg_desc);
+        if i < signature.python_signature.positional_only_parameters {
+            posonlyargs.push(arg);
+        } else {
+            args.push(arg)
+        }
+    }
+
+    if let Some(param) = &signature.python_signature.varargs {
+        vararg = Some(IntrospectionNode::Map(
+            [("name", IntrospectionNode::String(param.into()))].into(),
+        ));
     }
+
+    for (param, _) in &signature.python_signature.keyword_only_parameters {
+        let arg_desc = if let Some(arg_desc) = argument_desc.next() {
+            arg_desc
+        } else {
+            panic!("Less arguments than in python signature");
+        };
+        kwonlyargs.push(argument_introspection_data(param, arg_desc));
+    }
+
+    if let Some(param) = &signature.python_signature.kwargs {
+        kwarg = Some(IntrospectionNode::Map(
+            [
+                ("name", IntrospectionNode::String(param.into())),
+                ("kind", IntrospectionNode::String("VAR_KEYWORD".into())),
+            ]
+            .into(),
+        ));
+    }
+
+    let mut map = HashMap::new();
+    if !posonlyargs.is_empty() {
+        map.insert("posonlyargs", IntrospectionNode::List(posonlyargs));
+    }
+    if !args.is_empty() {
+        map.insert("args", IntrospectionNode::List(args));
+    }
+    if let Some(vararg) = vararg {
+        map.insert("vararg", vararg);
+    }
+    if !kwonlyargs.is_empty() {
+        map.insert("kwonlyargs", IntrospectionNode::List(kwonlyargs));
+    }
+    if let Some(kwarg) = kwarg {
+        map.insert("kwarg", kwarg);
+    }
+    IntrospectionNode::Map(map)
 }
 
-pub fn function_introspection_code(pyo3_crate_path: &PyO3CratePath, name: &str) -> TokenStream {
-    let stub = IntrospectionNode::Map(
-        [
-            ("type", IntrospectionNode::String("function")),
-            ("id", IntrospectionNode::IntrospectionId(None)),
-            ("name", IntrospectionNode::String(name)),
-        ]
-        .into(),
-    )
-    .emit(pyo3_crate_path);
-    let introspection_id = introspection_id_const();
-    quote! {
-        #stub
-        #introspection_id
+fn argument_introspection_data<'a>(
+    name: &'a str,
+    desc: &'a RegularArg<'_>,
+) -> IntrospectionNode<'a> {
+    let mut params: HashMap<_, _> = [("name", IntrospectionNode::String(name.into()))].into();
+    if desc.default_value.is_some() {
+        params.insert(
+            "default",
+            IntrospectionNode::String(desc.default_value().into()),
+        );
     }
+    IntrospectionNode::Map(params)
 }
 
 enum IntrospectionNode<'a> {
-    String(&'a str),
-    IntrospectionId(Option<&'a Ident>),
+    String(Cow<'a, str>),
+    IntrospectionId(Option<Cow<'a, Type>>),
     Map(HashMap<&'static str, IntrospectionNode<'a>>),
     List(Vec<IntrospectionNode<'a>>),
 }
@@ -125,7 +244,7 @@ impl IntrospectionNode<'_> {
     fn add_to_serialization(self, content: &mut ConcatenationBuilder) {
         match self {
             Self::String(string) => {
-                content.push_str_to_escape(string);
+                content.push_str_to_escape(&string);
             }
             Self::IntrospectionId(ident) => {
                 content.push_str("\"");
@@ -232,7 +351,8 @@ impl ToTokens for ConcatenationBuilderElement {
     }
 }
 
-fn introspection_id_const() -> TokenStream {
+/// Generates a new unique identifier for linking introspection objects together
+pub fn introspection_id_const() -> TokenStream {
     let id = unique_element_id().to_string();
     quote! {
         #[doc(hidden)]
@@ -248,3 +368,13 @@ fn unique_element_id() -> u64 {
         .hash(&mut hasher); // If there are multiple elements in the same call site
     hasher.finish()
 }
+
+fn ident_to_type(ident: &Ident) -> Cow<'static, Type> {
+    Cow::Owned(
+        TypePath {
+            path: ident.clone().into(),
+            qself: None,
+        }
+        .into(),
+    )
+}
diff --git a/pyo3-macros-backend/src/lib.rs b/pyo3-macros-backend/src/lib.rs
index 4baf58907b4..8919830dda9 100644
--- a/pyo3-macros-backend/src/lib.rs
+++ b/pyo3-macros-backend/src/lib.rs
@@ -9,6 +9,7 @@
 mod utils;
 
 mod attributes;
+mod derive_attributes;
 mod frompyobject;
 mod intopyobject;
 #[cfg(feature = "experimental-inspect")]
diff --git a/pyo3-macros-backend/src/method.rs b/pyo3-macros-backend/src/method.rs
index bc117874a5b..0ab5135e93a 100644
--- a/pyo3-macros-backend/src/method.rs
+++ b/pyo3-macros-backend/src/method.rs
@@ -27,6 +27,52 @@ pub struct RegularArg<'a> {
     pub option_wrapped_type: Option<&'a syn::Type>,
 }
 
+impl RegularArg<'_> {
+    pub fn default_value(&self) -> String {
+        if let Self {
+            default_value: Some(arg_default),
+            ..
+        } = self
+        {
+            match arg_default {
+                // literal values
+                syn::Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
+                    syn::Lit::Str(s) => s.token().to_string(),
+                    syn::Lit::Char(c) => c.token().to_string(),
+                    syn::Lit::Int(i) => i.base10_digits().to_string(),
+                    syn::Lit::Float(f) => f.base10_digits().to_string(),
+                    syn::Lit::Bool(b) => {
+                        if b.value() {
+                            "True".to_string()
+                        } else {
+                            "False".to_string()
+                        }
+                    }
+                    _ => "...".to_string(),
+                },
+                // None
+                syn::Expr::Path(syn::ExprPath { qself, path, .. })
+                    if qself.is_none() && path.is_ident("None") =>
+                {
+                    "None".to_string()
+                }
+                // others, unsupported yet so defaults to `...`
+                _ => "...".to_string(),
+            }
+        } else if let RegularArg {
+            option_wrapped_type: Some(..),
+            ..
+        } = self
+        {
+            // functions without a `#[pyo3(signature = (...))]` option
+            // will treat trailing `Option<T>` arguments as having a default of `None`
+            "None".to_string()
+        } else {
+            "...".to_string()
+        }
+    }
+}
+
 /// Pythons *args argument
 #[derive(Clone, Debug)]
 pub struct VarargsArg<'a> {
@@ -177,6 +223,14 @@ impl<'a> FnArg<'a> {
             }
         }
     }
+
+    pub fn default_value(&self) -> String {
+        if let Self::Regular(args) = self {
+            args.default_value()
+        } else {
+            "...".to_string()
+        }
+    }
 }
 
 fn handle_argument_error(pat: &syn::Pat) -> syn::Error {
@@ -593,10 +647,10 @@ impl<'a> FnSpec<'a> {
                     .fold(first.span(), |s, next| s.join(next.span()).unwrap_or(s));
                 let span = span.join(last.span()).unwrap_or(span);
                 // List all the attributes in the error message
-                let mut msg = format!("`{}` may not be combined with", first);
+                let mut msg = format!("`{first}` may not be combined with");
                 let mut is_first = true;
                 for attr in &*rest {
-                    msg.push_str(&format!(" `{}`", attr));
+                    msg.push_str(&format!(" `{attr}`"));
                     if is_first {
                         is_first = false;
                     } else {
@@ -606,7 +660,7 @@ impl<'a> FnSpec<'a> {
                 if !rest.is_empty() {
                     msg.push_str(" and");
                 }
-                msg.push_str(&format!(" `{}`", last));
+                msg.push_str(&format!(" `{last}`"));
                 bail_spanned!(span => msg)
             }
         };
diff --git a/pyo3-macros-backend/src/module.rs b/pyo3-macros-backend/src/module.rs
index 7ee165cbd27..860a3b6d857 100644
--- a/pyo3-macros-backend/src/module.rs
+++ b/pyo3-macros-backend/src/module.rs
@@ -1,7 +1,7 @@
 //! Code generation for the function that initializes a python module and adds classes and function.
 
 #[cfg(feature = "experimental-inspect")]
-use crate::introspection::module_introspection_code;
+use crate::introspection::{introspection_id_const, module_introspection_code};
 use crate::{
     attributes::{
         self, kw, take_attributes, take_pyo3_options, CrateAttribute, GILUsedAttribute,
@@ -149,6 +149,8 @@ pub fn pymodule_module_impl(
     }
 
     let mut pymodule_init = None;
+    let mut module_consts = Vec::new();
+    let mut module_consts_cfg_attrs = Vec::new();
 
     for item in &mut *items {
         match item {
@@ -168,7 +170,7 @@ pub fn pymodule_module_impl(
             Item::Fn(item_fn) => {
                 ensure_spanned!(
                     !has_attribute(&item_fn.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
                 let is_pymodule_init =
                     find_and_remove_attribute(&mut item_fn.attrs, "pymodule_init");
@@ -199,7 +201,7 @@ pub fn pymodule_module_impl(
             Item::Struct(item_struct) => {
                 ensure_spanned!(
                     !has_attribute(&item_struct.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
                 if has_attribute(&item_struct.attrs, "pyclass")
                     || has_attribute_with_namespace(
@@ -227,7 +229,7 @@ pub fn pymodule_module_impl(
             Item::Enum(item_enum) => {
                 ensure_spanned!(
                     !has_attribute(&item_enum.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
                 if has_attribute(&item_enum.attrs, "pyclass")
                     || has_attribute_with_namespace(&item_enum.attrs, Some(pyo3_path), &["pyclass"])
@@ -251,7 +253,7 @@ pub fn pymodule_module_impl(
             Item::Mod(item_mod) => {
                 ensure_spanned!(
                     !has_attribute(&item_mod.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
                 if has_attribute(&item_mod.attrs, "pymodule")
                     || has_attribute_with_namespace(&item_mod.attrs, Some(pyo3_path), &["pymodule"])
@@ -278,61 +280,63 @@ pub fn pymodule_module_impl(
             Item::ForeignMod(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::Trait(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::Const(item) => {
-                ensure_spanned!(
-                    !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
-                );
+                if !find_and_remove_attribute(&mut item.attrs, "pymodule_export") {
+                    continue;
+                }
+
+                module_consts.push(item.ident.clone());
+                module_consts_cfg_attrs.push(get_cfg_attributes(&item.attrs));
             }
             Item::Static(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::Macro(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::ExternCrate(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::Impl(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::TraitAlias(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::Type(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             Item::Union(item) => {
                 ensure_spanned!(
                     !has_attribute(&item.attrs, "pymodule_export"),
-                    item.span() => "`#[pymodule_export]` may only be used on `use` statements"
+                    item.span() => "`#[pymodule_export]` may only be used on `use` or `const` statements"
                 );
             }
             _ => (),
@@ -348,6 +352,10 @@ pub fn pymodule_module_impl(
     );
     #[cfg(not(feature = "experimental-inspect"))]
     let introspection = quote! {};
+    #[cfg(feature = "experimental-inspect")]
+    let introspection_id = introspection_id_const();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_id = quote! {};
 
     let module_def = quote! {{
         use #pyo3_path::impl_::pymodule as impl_;
@@ -368,6 +376,8 @@ pub fn pymodule_module_impl(
         options.gil_used.map_or(true, |op| op.value.value),
     );
 
+    let module_consts_names = module_consts.iter().map(|i| i.unraw().to_string());
+
     Ok(quote!(
         #(#attrs)*
         #vis #mod_token #ident {
@@ -375,6 +385,7 @@ pub fn pymodule_module_impl(
 
             #initialization
             #introspection
+            #introspection_id
 
             fn __pyo3_pymodule(module: &#pyo3_path::Bound<'_, #pyo3_path::types::PyModule>) -> #pyo3_path::PyResult<()> {
                 use #pyo3_path::impl_::pymodule::PyAddToModule;
@@ -382,6 +393,12 @@ pub fn pymodule_module_impl(
                     #(#module_items_cfg_attrs)*
                     #module_items::_PYO3_DEF.add_to_module(module)?;
                 )*
+
+                #(
+                    #(#module_consts_cfg_attrs)*
+                    #pyo3_path::types::PyModuleMethods::add(module, #module_consts_names, #module_consts)?;
+                )*
+
                 #pymodule_init
                 ::std::result::Result::Ok(())
             }
@@ -418,6 +435,10 @@ pub fn pymodule_function_impl(
     let introspection = module_introspection_code(pyo3_path, &name.to_string(), &[], &[]);
     #[cfg(not(feature = "experimental-inspect"))]
     let introspection = quote! {};
+    #[cfg(feature = "experimental-inspect")]
+    let introspection_id = introspection_id_const();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_id = quote! {};
 
     // Module function called with optional Python<'_> marker as first arg, followed by the module.
     let mut module_args = Vec::new();
@@ -432,6 +453,7 @@ pub fn pymodule_function_impl(
         #vis mod #ident {
             #initialization
             #introspection
+            #introspection_id
         }
 
         // Generate the definition inside an anonymous function in the same scope as the original function -
@@ -466,7 +488,7 @@ fn module_initialization(
     gil_used: bool,
 ) -> TokenStream {
     let Ctx { pyo3_path, .. } = ctx;
-    let pyinit_symbol = format!("PyInit_{}", name);
+    let pyinit_symbol = format!("PyInit_{name}");
     let name = name.to_string();
     let pyo3_name = LitCStr::new(CString::new(name).unwrap(), Span::call_site(), ctx);
 
diff --git a/pyo3-macros-backend/src/params.rs b/pyo3-macros-backend/src/params.rs
index 6ff065e7458..087e97f500c 100644
--- a/pyo3-macros-backend/src/params.rs
+++ b/pyo3-macros-backend/src/params.rs
@@ -1,4 +1,4 @@
-use crate::utils::{deprecated_from_py_with, Ctx, TypeExt as _};
+use crate::utils::{Ctx, TypeExt as _};
 use crate::{
     attributes::FromPyWithAttribute,
     method::{FnArg, FnSpec, RegularArg},
@@ -62,9 +62,7 @@ pub fn impl_arg_params(
         .filter_map(|(i, arg)| {
             let from_py_with = &arg.from_py_with()?.value;
             let from_py_with_holder = format_ident!("from_py_with_{}", i);
-            let d = deprecated_from_py_with(from_py_with).unwrap_or_default();
             Some(quote_spanned! { from_py_with.span() =>
-                #d
                 let #from_py_with_holder = #from_py_with;
             })
         })
diff --git a/pyo3-macros-backend/src/pyclass.rs b/pyo3-macros-backend/src/pyclass.rs
index ed15917279e..ab86138338b 100644
--- a/pyo3-macros-backend/src/pyclass.rs
+++ b/pyo3-macros-backend/src/pyclass.rs
@@ -15,7 +15,7 @@ use crate::attributes::{
     StrFormatterAttribute,
 };
 #[cfg(feature = "experimental-inspect")]
-use crate::introspection::class_introspection_code;
+use crate::introspection::{class_introspection_code, introspection_id_const};
 use crate::konst::{ConstAttributes, ConstSpec};
 use crate::method::{FnArg, FnSpec, PyArg, RegularArg};
 use crate::pyfunction::ConstructorAttribute;
@@ -25,7 +25,7 @@ use crate::pymethod::{
     MethodAndSlotDef, PropertyType, SlotDef, __GETITEM__, __HASH__, __INT__, __LEN__, __REPR__,
     __RICHCMP__, __STR__,
 };
-use crate::pyversions::is_abi3_before;
+use crate::pyversions::{is_abi3_before, is_py_before};
 use crate::utils::{self, apply_renaming_rule, Ctx, LitCStr, PythonDoc};
 use crate::PyFunctionOptions;
 
@@ -71,6 +71,7 @@ pub struct PyClassPyO3Options {
     pub freelist: Option<FreelistAttribute>,
     pub frozen: Option<kw::frozen>,
     pub hash: Option<kw::hash>,
+    pub immutable_type: Option<kw::immutable_type>,
     pub mapping: Option<kw::mapping>,
     pub module: Option<ModuleAttribute>,
     pub name: Option<NameAttribute>,
@@ -82,6 +83,7 @@ pub struct PyClassPyO3Options {
     pub subclass: Option<kw::subclass>,
     pub unsendable: Option<kw::unsendable>,
     pub weakref: Option<kw::weakref>,
+    pub generic: Option<kw::generic>,
 }
 
 pub enum PyClassPyO3Option {
@@ -94,6 +96,7 @@ pub enum PyClassPyO3Option {
     Frozen(kw::frozen),
     GetAll(kw::get_all),
     Hash(kw::hash),
+    ImmutableType(kw::immutable_type),
     Mapping(kw::mapping),
     Module(ModuleAttribute),
     Name(NameAttribute),
@@ -105,6 +108,7 @@ pub enum PyClassPyO3Option {
     Subclass(kw::subclass),
     Unsendable(kw::unsendable),
     Weakref(kw::weakref),
+    Generic(kw::generic),
 }
 
 impl Parse for PyClassPyO3Option {
@@ -128,6 +132,8 @@ impl Parse for PyClassPyO3Option {
             input.parse().map(PyClassPyO3Option::GetAll)
         } else if lookahead.peek(attributes::kw::hash) {
             input.parse().map(PyClassPyO3Option::Hash)
+        } else if lookahead.peek(attributes::kw::immutable_type) {
+            input.parse().map(PyClassPyO3Option::ImmutableType)
         } else if lookahead.peek(attributes::kw::mapping) {
             input.parse().map(PyClassPyO3Option::Mapping)
         } else if lookahead.peek(attributes::kw::module) {
@@ -150,6 +156,8 @@ impl Parse for PyClassPyO3Option {
             input.parse().map(PyClassPyO3Option::Unsendable)
         } else if lookahead.peek(attributes::kw::weakref) {
             input.parse().map(PyClassPyO3Option::Weakref)
+        } else if lookahead.peek(attributes::kw::generic) {
+            input.parse().map(PyClassPyO3Option::Generic)
         } else {
             Err(lookahead.error())
         }
@@ -203,6 +211,13 @@ impl PyClassPyO3Options {
             PyClassPyO3Option::Freelist(freelist) => set_option!(freelist),
             PyClassPyO3Option::Frozen(frozen) => set_option!(frozen),
             PyClassPyO3Option::GetAll(get_all) => set_option!(get_all),
+            PyClassPyO3Option::ImmutableType(immutable_type) => {
+                ensure_spanned!(
+                    !(is_py_before(3, 10) || is_abi3_before(3, 14)),
+                    immutable_type.span() => "`immutable_type` requires Python >= 3.10 or >= 3.14 (ABI3)"
+                );
+                set_option!(immutable_type)
+            }
             PyClassPyO3Option::Hash(hash) => set_option!(hash),
             PyClassPyO3Option::Mapping(mapping) => set_option!(mapping),
             PyClassPyO3Option::Module(module) => set_option!(module),
@@ -221,6 +236,7 @@ impl PyClassPyO3Options {
                 );
                 set_option!(weakref);
             }
+            PyClassPyO3Option::Generic(generic) => set_option!(generic),
         }
         Ok(())
     }
@@ -418,6 +434,21 @@ fn impl_class(
         }
     }
 
+    let mut default_methods = descriptors_to_items(
+        cls,
+        args.options.rename_all.as_ref(),
+        args.options.frozen,
+        field_options,
+        ctx,
+    )?;
+
+    let (default_class_geitem, default_class_geitem_method) =
+        pyclass_class_geitem(&args.options, &syn::parse_quote!(#cls), ctx)?;
+
+    if let Some(default_class_geitem_method) = default_class_geitem_method {
+        default_methods.push(default_class_geitem_method);
+    }
+
     let (default_str, default_str_slot) =
         implement_pyclass_str(&args.options, &syn::parse_quote!(#cls), ctx);
 
@@ -432,21 +463,9 @@ fn impl_class(
     slots.extend(default_hash_slot);
     slots.extend(default_str_slot);
 
-    let py_class_impl = PyClassImplsBuilder::new(
-        cls,
-        args,
-        methods_type,
-        descriptors_to_items(
-            cls,
-            args.options.rename_all.as_ref(),
-            args.options.frozen,
-            field_options,
-            ctx,
-        )?,
-        slots,
-    )
-    .doc(doc)
-    .impl_all(ctx)?;
+    let py_class_impl = PyClassImplsBuilder::new(cls, args, methods_type, default_methods, slots)
+        .doc(doc)
+        .impl_all(ctx)?;
 
     Ok(quote! {
         impl #pyo3_path::types::DerefToPyAny for #cls {}
@@ -461,6 +480,7 @@ fn impl_class(
             #default_richcmp
             #default_hash
             #default_str
+            #default_class_geitem
         }
     })
 }
@@ -503,6 +523,10 @@ pub fn build_py_enum(
         bail_spanned!(enum_.brace_token.span.join() => "#[pyclass] can't be used on enums without any variants");
     }
 
+    if let Some(generic) = &args.options.generic {
+        bail_spanned!(generic.span() => "enums do not support #[pyclass(generic)]");
+    }
+
     let doc = utils::get_doc(&enum_.attrs, None, ctx);
     let enum_ = PyClassEnum::new(enum_)?;
     impl_enum(enum_, &args, doc, method_type, ctx)
@@ -1469,7 +1493,7 @@ fn generate_default_protocol_slot(
     slot.generate_type_slot(
         &syn::parse_quote!(#cls),
         &spec,
-        &format!("__default_{}__", name),
+        &format!("__default_{name}__"),
         ctx,
     )
 }
@@ -1997,6 +2021,46 @@ fn pyclass_hash(
     }
 }
 
+fn pyclass_class_geitem(
+    options: &PyClassPyO3Options,
+    cls: &syn::Type,
+    ctx: &Ctx,
+) -> Result<(Option<syn::ImplItemFn>, Option<MethodAndMethodDef>)> {
+    let Ctx { pyo3_path, .. } = ctx;
+    match options.generic {
+        Some(_) => {
+            let ident = format_ident!("__class_getitem__");
+            let mut class_geitem_impl: syn::ImplItemFn = {
+                parse_quote! {
+                    #[classmethod]
+                    fn #ident<'py>(
+                        cls: &#pyo3_path::Bound<'py, #pyo3_path::types::PyType>,
+                        key: &#pyo3_path::Bound<'py, #pyo3_path::types::PyAny>
+                    ) -> #pyo3_path::PyResult<#pyo3_path::Bound<'py, #pyo3_path::types::PyGenericAlias>> {
+                        #pyo3_path::types::PyGenericAlias::new(cls.py(), cls.as_any(), key)
+                    }
+                }
+            };
+
+            let spec = FnSpec::parse(
+                &mut class_geitem_impl.sig,
+                &mut class_geitem_impl.attrs,
+                Default::default(),
+            )?;
+
+            let class_geitem_method = crate::pymethod::impl_py_method_def(
+                cls,
+                &spec,
+                &spec.get_doc(&class_geitem_impl.attrs, ctx),
+                Some(quote!(#pyo3_path::ffi::METH_CLASS)),
+                ctx,
+            )?;
+            Ok((Some(class_geitem_impl), Some(class_geitem_method)))
+        }
+        None => Ok((None, None)),
+    }
+}
+
 /// Implements most traits used by `#[pyclass]`.
 ///
 /// Specifically, it implements traits that only depend on class name,
@@ -2145,6 +2209,7 @@ impl<'a> PyClassImplsBuilder<'a> {
         let is_subclass = self.attr.options.extends.is_some();
         let is_mapping: bool = self.attr.options.mapping.is_some();
         let is_sequence: bool = self.attr.options.sequence.is_some();
+        let is_immutable_type = self.attr.options.immutable_type.is_some();
 
         ensure_spanned!(
             !(is_mapping && is_sequence),
@@ -2278,6 +2343,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                 const IS_SUBCLASS: bool = #is_subclass;
                 const IS_MAPPING: bool = #is_mapping;
                 const IS_SEQUENCE: bool = #is_sequence;
+                const IS_IMMUTABLE_TYPE: bool = #is_immutable_type;
 
                 type BaseType = #base;
                 type ThreadChecker = #thread_checker;
@@ -2388,7 +2454,15 @@ impl<'a> PyClassImplsBuilder<'a> {
     fn impl_introspection(&self, ctx: &Ctx) -> TokenStream {
         let Ctx { pyo3_path, .. } = ctx;
         let name = get_class_python_name(self.cls, self.attr).to_string();
-        class_introspection_code(pyo3_path, self.cls, &name)
+        let ident = self.cls;
+        let static_introspection = class_introspection_code(pyo3_path, ident, &name);
+        let introspection_id = introspection_id_const();
+        quote! {
+            #static_introspection
+            impl #ident {
+                #introspection_id
+            }
+        }
     }
 
     #[cfg(not(feature = "experimental-inspect"))]
diff --git a/pyo3-macros-backend/src/pyfunction.rs b/pyo3-macros-backend/src/pyfunction.rs
index 68976190fbe..e512ca1cabc 100644
--- a/pyo3-macros-backend/src/pyfunction.rs
+++ b/pyo3-macros-backend/src/pyfunction.rs
@@ -1,5 +1,5 @@
 #[cfg(feature = "experimental-inspect")]
-use crate::introspection::function_introspection_code;
+use crate::introspection::{function_introspection_code, introspection_id_const};
 use crate::utils::Ctx;
 use crate::{
     attributes::{
@@ -226,6 +226,26 @@ pub fn impl_wrap_pyfunction(
         FunctionSignature::from_arguments(arguments)
     };
 
+    let vis = &func.vis;
+    let name = &func.sig.ident;
+
+    #[cfg(feature = "experimental-inspect")]
+    let introspection = function_introspection_code(
+        pyo3_path,
+        Some(name),
+        &name.to_string(),
+        &signature,
+        None,
+        [] as [String; 0],
+        None,
+    );
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection = quote! {};
+    #[cfg(feature = "experimental-inspect")]
+    let introspection_id = introspection_id_const();
+    #[cfg(not(feature = "experimental-inspect"))]
+    let introspection_id = quote! {};
+
     let spec = method::FnSpec {
         tp,
         name: &func.sig.ident,
@@ -237,16 +257,9 @@ pub fn impl_wrap_pyfunction(
         unsafety: func.sig.unsafety,
     };
 
-    let vis = &func.vis;
-    let name = &func.sig.ident;
-
     let wrapper_ident = format_ident!("__pyfunction_{}", spec.name);
     let wrapper = spec.get_wrapper_function(&wrapper_ident, None, ctx)?;
     let methoddef = spec.get_methoddef(wrapper_ident, &spec.get_doc(&func.attrs, ctx), ctx);
-    #[cfg(feature = "experimental-inspect")]
-    let introspection = function_introspection_code(pyo3_path, &name.to_string());
-    #[cfg(not(feature = "experimental-inspect"))]
-    let introspection = quote! {};
 
     let wrapped_pyfunction = quote! {
         // Create a module with the same name as the `#[pyfunction]` - this way `use <the function>`
@@ -255,7 +268,7 @@ pub fn impl_wrap_pyfunction(
         #vis mod #name {
             pub(crate) struct MakeDef;
             pub const _PYO3_DEF: #pyo3_path::impl_::pymethods::PyMethodDef = MakeDef::_PYO3_DEF;
-            #introspection
+            #introspection_id
         }
 
         // Generate the definition inside an anonymous function in the same scope as the original function -
@@ -269,6 +282,8 @@ pub fn impl_wrap_pyfunction(
 
         #[allow(non_snake_case)]
         #wrapper
+
+        #introspection
     };
     Ok(wrapped_pyfunction)
 }
diff --git a/pyo3-macros-backend/src/pyfunction/signature.rs b/pyo3-macros-backend/src/pyfunction/signature.rs
index deea3dfa052..fac1541bdf1 100644
--- a/pyo3-macros-backend/src/pyfunction/signature.rs
+++ b/pyo3-macros-backend/src/pyfunction/signature.rs
@@ -491,49 +491,11 @@ impl<'a> FunctionSignature<'a> {
     }
 
     fn default_value_for_parameter(&self, parameter: &str) -> String {
-        let mut default = "...".to_string();
         if let Some(fn_arg) = self.arguments.iter().find(|arg| arg.name() == parameter) {
-            if let FnArg::Regular(RegularArg {
-                default_value: Some(arg_default),
-                ..
-            }) = fn_arg
-            {
-                match arg_default {
-                    // literal values
-                    syn::Expr::Lit(syn::ExprLit { lit, .. }) => match lit {
-                        syn::Lit::Str(s) => default = s.token().to_string(),
-                        syn::Lit::Char(c) => default = c.token().to_string(),
-                        syn::Lit::Int(i) => default = i.base10_digits().to_string(),
-                        syn::Lit::Float(f) => default = f.base10_digits().to_string(),
-                        syn::Lit::Bool(b) => {
-                            default = if b.value() {
-                                "True".to_string()
-                            } else {
-                                "False".to_string()
-                            }
-                        }
-                        _ => {}
-                    },
-                    // None
-                    syn::Expr::Path(syn::ExprPath {
-                        qself: None, path, ..
-                    }) if path.is_ident("None") => {
-                        default = "None".to_string();
-                    }
-                    // others, unsupported yet so defaults to `...`
-                    _ => {}
-                }
-            } else if let FnArg::Regular(RegularArg {
-                option_wrapped_type: Some(..),
-                ..
-            }) = fn_arg
-            {
-                // functions without a `#[pyo3(signature = (...))]` option
-                // will treat trailing `Option<T>` arguments as having a default of `None`
-                default = "None".to_string();
-            }
+            fn_arg.default_value()
+        } else {
+            "...".to_string()
         }
-        default
     }
 
     pub fn text_signature(&self, self_argument: Option<&str>) -> String {
diff --git a/pyo3-macros-backend/src/pyimpl.rs b/pyo3-macros-backend/src/pyimpl.rs
index 72f06721ec4..90b0d961cd8 100644
--- a/pyo3-macros-backend/src/pyimpl.rs
+++ b/pyo3-macros-backend/src/pyimpl.rs
@@ -1,14 +1,19 @@
 use std::collections::HashSet;
 
+#[cfg(feature = "experimental-inspect")]
+use crate::introspection::function_introspection_code;
+#[cfg(feature = "experimental-inspect")]
+use crate::method::{FnSpec, FnType};
 use crate::utils::{has_attribute, has_attribute_with_namespace, Ctx, PyO3CratePath};
 use crate::{
     attributes::{take_pyo3_options, CrateAttribute},
     konst::{ConstAttributes, ConstSpec},
     pyfunction::PyFunctionOptions,
-    pymethod::{self, is_proto_method, MethodAndMethodDef, MethodAndSlotDef},
+    pymethod::{
+        self, is_proto_method, GeneratedPyMethod, MethodAndMethodDef, MethodAndSlotDef, PyMethod,
+    },
 };
 use proc_macro2::TokenStream;
-use pymethod::GeneratedPyMethod;
 use quote::{format_ident, quote};
 use syn::ImplItemFn;
 use syn::{
@@ -110,7 +115,7 @@ pub fn impl_methods(
     methods_type: PyClassMethodsType,
     options: PyImplOptions,
 ) -> syn::Result<TokenStream> {
-    let mut trait_impls = Vec::new();
+    let mut extra_fragments = Vec::new();
     let mut proto_impls = Vec::new();
     let mut methods = Vec::new();
     let mut associated_methods = Vec::new();
@@ -125,9 +130,10 @@ pub fn impl_methods(
                 fun_options.krate = fun_options.krate.or_else(|| options.krate.clone());
 
                 check_pyfunction(&ctx.pyo3_path, meth)?;
-
-                match pymethod::gen_py_method(ty, &mut meth.sig, &mut meth.attrs, fun_options, ctx)?
-                {
+                let method = PyMethod::parse(&mut meth.sig, &mut meth.attrs, fun_options)?;
+                #[cfg(feature = "experimental-inspect")]
+                extra_fragments.push(method_introspection_code(&method.spec, ty, ctx));
+                match pymethod::gen_py_method(ty, method, &meth.attrs, ctx)? {
                     GeneratedPyMethod::Method(MethodAndMethodDef {
                         associated_method,
                         method_def,
@@ -139,7 +145,7 @@ pub fn impl_methods(
                     GeneratedPyMethod::SlotTraitImpl(method_name, token_stream) => {
                         implemented_proto_fragments.insert(method_name);
                         let attrs = get_cfg_attributes(&meth.attrs);
-                        trait_impls.push(quote!(#(#attrs)* #token_stream));
+                        extra_fragments.push(quote!(#(#attrs)* #token_stream));
                     }
                     GeneratedPyMethod::Proto(MethodAndSlotDef {
                         associated_method,
@@ -193,7 +199,7 @@ pub fn impl_methods(
     };
 
     Ok(quote! {
-        #(#trait_impls)*
+        #(#extra_fragments)*
 
         #items
 
@@ -336,3 +342,52 @@ pub(crate) fn get_cfg_attributes(attrs: &[syn::Attribute]) -> Vec<&syn::Attribut
         .filter(|attr| attr.path().is_ident("cfg"))
         .collect()
 }
+
+#[cfg(feature = "experimental-inspect")]
+fn method_introspection_code(spec: &FnSpec<'_>, parent: &syn::Type, ctx: &Ctx) -> TokenStream {
+    let Ctx { pyo3_path, .. } = ctx;
+
+    // We introduce self/cls argument and setup decorators
+    let name = spec.python_name.to_string();
+    let mut first_argument = None;
+    let mut decorators = Vec::new();
+    match &spec.tp {
+        FnType::Getter(_) => {
+            first_argument = Some("self");
+            decorators.push("property".into());
+        }
+        FnType::Setter(_) => {
+            first_argument = Some("self");
+            decorators.push(format!("{name}.setter"));
+        }
+        FnType::Fn(_) => {
+            first_argument = Some("self");
+        }
+        FnType::FnNew | FnType::FnNewClass(_) => {
+            first_argument = Some("cls");
+        }
+        FnType::FnClass(_) => {
+            first_argument = Some("cls");
+            decorators.push("classmethod".into());
+        }
+        FnType::FnStatic => {
+            decorators.push("staticmethod".into());
+        }
+        FnType::FnModule(_) => (), // TODO: not sure this can happen
+        FnType::ClassAttribute => {
+            first_argument = Some("cls");
+            // TODO: this combination only works with Python 3.9-3.11 https://docs.python.org/3.11/library/functions.html#classmethod
+            decorators.push("classmethod".into());
+            decorators.push("property".into());
+        }
+    }
+    function_introspection_code(
+        pyo3_path,
+        None,
+        &name,
+        &spec.signature,
+        first_argument,
+        decorators,
+        Some(parent),
+    )
+}
diff --git a/pyo3-macros-backend/src/pymethod.rs b/pyo3-macros-backend/src/pymethod.rs
index b4637b48012..434a96e9dde 100644
--- a/pyo3-macros-backend/src/pymethod.rs
+++ b/pyo3-macros-backend/src/pymethod.rs
@@ -4,8 +4,8 @@ use std::ffi::CString;
 use crate::attributes::{FromPyWithAttribute, NameAttribute, RenamingRule};
 use crate::method::{CallingConvention, ExtractErrorMode, PyArg};
 use crate::params::{impl_regular_arg_param, Holders};
-use crate::utils::{deprecated_from_py_with, PythonDoc, TypeExt as _};
 use crate::utils::{Ctx, LitCStr};
+use crate::utils::{PythonDoc, TypeExt as _};
 use crate::{
     method::{FnArg, FnSpec, FnType, SelfType},
     pyfunction::PyFunctionOptions,
@@ -40,7 +40,7 @@ pub enum GeneratedPyMethod {
 pub struct PyMethod<'a> {
     kind: PyMethodKind,
     method_name: String,
-    spec: FnSpec<'a>,
+    pub spec: FnSpec<'a>,
 }
 
 enum PyMethodKind {
@@ -160,11 +160,13 @@ enum PyMethodProtoKind {
 }
 
 impl<'a> PyMethod<'a> {
-    fn parse(
+    pub fn parse(
         sig: &'a mut syn::Signature,
         meth_attrs: &mut Vec<syn::Attribute>,
         options: PyFunctionOptions,
     ) -> Result<Self> {
+        check_generic(sig)?;
+        ensure_function_options_valid(&options)?;
         let spec = FnSpec::parse(sig, meth_attrs, options)?;
 
         let method_name = spec.python_name.to_string();
@@ -187,14 +189,10 @@ pub fn is_proto_method(name: &str) -> bool {
 
 pub fn gen_py_method(
     cls: &syn::Type,
-    sig: &mut syn::Signature,
-    meth_attrs: &mut Vec<syn::Attribute>,
-    options: PyFunctionOptions,
+    method: PyMethod<'_>,
+    meth_attrs: &[syn::Attribute],
     ctx: &Ctx,
 ) -> Result<GeneratedPyMethod> {
-    check_generic(sig)?;
-    ensure_function_options_valid(&options)?;
-    let method = PyMethod::parse(sig, meth_attrs, options)?;
     let spec = &method.spec;
     let Ctx { pyo3_path, .. } = ctx;
 
@@ -278,7 +276,7 @@ pub fn gen_py_method(
 }
 
 pub fn check_generic(sig: &syn::Signature) -> syn::Result<()> {
-    let err_msg = |typ| format!("Python functions cannot have generic {} parameters", typ);
+    let err_msg = |typ| format!("Python functions cannot have generic {typ} parameters");
     for param in &sig.generics.params {
         match param {
             syn::GenericParam::Lifetime(_) => {}
@@ -659,10 +657,8 @@ pub fn impl_py_setter_def(
             let (from_py_with, ident) =
                 if let Some(from_py_with) = &value_arg.from_py_with().as_ref().map(|f| &f.value) {
                     let ident = syn::Ident::new("from_py_with", from_py_with.span());
-                    let d = deprecated_from_py_with(from_py_with).unwrap_or_default();
                     (
                         quote_spanned! { from_py_with.span() =>
-                            #d
                             let #ident = #from_py_with;
                         },
                         ident,
@@ -1603,7 +1599,7 @@ fn extract_proto_arguments(
         if let FnArg::Py(..) = arg {
             args.push(quote! { py });
         } else {
-            let ident = syn::Ident::new(&format!("arg{}", non_python_args), Span::call_site());
+            let ident = syn::Ident::new(&format!("arg{non_python_args}"), Span::call_site());
             let conversions = proto_args.get(non_python_args)
                 .ok_or_else(|| err_spanned!(arg.ty().span() => format!("Expected at most {} non-python arguments", proto_args.len())))?
                 .extract(&ident, arg, extract_error_mode, holders, ctx);
diff --git a/pyo3-macros-backend/src/pyversions.rs b/pyo3-macros-backend/src/pyversions.rs
index 4c0998667d8..3c5ac47fb84 100644
--- a/pyo3-macros-backend/src/pyversions.rs
+++ b/pyo3-macros-backend/src/pyversions.rs
@@ -2,5 +2,10 @@ use pyo3_build_config::PythonVersion;
 
 pub fn is_abi3_before(major: u8, minor: u8) -> bool {
     let config = pyo3_build_config::get();
-    config.abi3 && config.version < PythonVersion { major, minor }
+    config.abi3 && !config.is_free_threaded() && config.version < PythonVersion { major, minor }
+}
+
+pub fn is_py_before(major: u8, minor: u8) -> bool {
+    let config = pyo3_build_config::get();
+    config.version < PythonVersion { major, minor }
 }
diff --git a/pyo3-macros-backend/src/utils.rs b/pyo3-macros-backend/src/utils.rs
index bdec23388df..09f86158834 100644
--- a/pyo3-macros-backend/src/utils.rs
+++ b/pyo3-macros-backend/src/utils.rs
@@ -1,6 +1,6 @@
-use crate::attributes::{CrateAttribute, ExprPathWrap, RenamingRule};
+use crate::attributes::{CrateAttribute, RenamingRule};
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, quote_spanned, ToTokens};
+use quote::{quote, ToTokens};
 use std::ffi::CString;
 use syn::spanned::Spanned;
 use syn::{punctuated::Punctuated, Token};
@@ -324,20 +324,6 @@ pub(crate) fn has_attribute_with_namespace(
     })
 }
 
-pub(crate) fn deprecated_from_py_with(expr_path: &ExprPathWrap) -> Option<TokenStream> {
-    let path = quote!(#expr_path).to_string();
-    let msg =
-        format!("remove the quotes from the literal\n= help: use `{path}` instead of `\"{path}\"`");
-    expr_path.from_lit_str.then(|| {
-        quote_spanned! { expr_path.span() =>
-            #[deprecated(since = "0.24.0", note = #msg)]
-            #[allow(dead_code)]
-            const LIT_STR_DEPRECATION: () = ();
-            let _: () = LIT_STR_DEPRECATION;
-        }
-    })
-}
-
 pub(crate) trait TypeExt {
     /// Replaces all explicit lifetimes in `self` with elided (`'_`) lifetimes
     ///
diff --git a/pyo3-macros/Cargo.toml b/pyo3-macros/Cargo.toml
index c7bd43fad69..7df15c23f76 100644
--- a/pyo3-macros/Cargo.toml
+++ b/pyo3-macros/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pyo3-macros"
-version = "0.25.0-dev"
+version = "0.25.0"
 description = "Proc macros for PyO3 package"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 keywords = ["pyo3", "python", "cpython", "ffi"]
@@ -23,7 +23,7 @@ experimental-inspect = ["pyo3-macros-backend/experimental-inspect"]
 proc-macro2 = { version = "1.0.60", default-features = false }
 quote = "1"
 syn = { version = "2", features = ["full", "extra-traits"] }
-pyo3-macros-backend = { path = "../pyo3-macros-backend", version = "=0.25.0-dev" }
+pyo3-macros-backend = { path = "../pyo3-macros-backend", version = "=0.25.0" }
 
 [lints]
 workspace = true
diff --git a/pyproject.toml b/pyproject.toml
index 1ff0f0332de..adfe3a27348 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -3,7 +3,7 @@
 
 [tool.towncrier]
 filename = "CHANGELOG.md"
-version = "0.25.0-dev"
+version = "0.25.0"
 start_string = "<!-- towncrier release notes start -->\n"
 template = ".towncrier.template.md"
 title_format = "## [{version}] - {project_date}"
diff --git a/pytests/pytest.ini b/pytests/pytest.ini
new file mode 100644
index 00000000000..3d62037f722
--- /dev/null
+++ b/pytests/pytest.ini
@@ -0,0 +1,3 @@
+# see https://github.com/PyO3/pyo3/issues/5094 for details
+[pytest]
+filterwarnings = ignore::DeprecationWarning:pytest_asyncio.*
\ No newline at end of file
diff --git a/pytests/src/pyclasses.rs b/pytests/src/pyclasses.rs
index 1091e6c16b3..4e681b2c941 100644
--- a/pytests/src/pyclasses.rs
+++ b/pytests/src/pyclasses.rs
@@ -80,8 +80,7 @@ impl AssertingBaseClass {
     fn new(cls: &Bound<'_, PyType>, expected_type: Bound<'_, PyType>) -> PyResult<Self> {
         if !cls.is(&expected_type) {
             return Err(PyValueError::new_err(format!(
-                "{:?} != {:?}",
-                cls, expected_type
+                "{cls:?} != {expected_type:?}"
             )));
         }
         Ok(Self)
@@ -104,6 +103,45 @@ impl ClassWithDict {
     }
 }
 
+#[pyclass]
+struct ClassWithDecorators {
+    attr: usize,
+}
+
+#[pymethods]
+impl ClassWithDecorators {
+    #[new]
+    #[classmethod]
+    fn new(_cls: Bound<'_, PyType>) -> Self {
+        Self { attr: 0 }
+    }
+
+    #[getter]
+    fn get_attr(&self) -> usize {
+        self.attr
+    }
+
+    #[setter]
+    fn set_attr(&mut self, value: usize) {
+        self.attr = value;
+    }
+
+    #[classmethod]
+    fn cls_method(_cls: &Bound<'_, PyType>) -> usize {
+        1
+    }
+
+    #[staticmethod]
+    fn static_method() -> usize {
+        2
+    }
+
+    #[classattr]
+    fn cls_attribute() -> usize {
+        3
+    }
+}
+
 #[pymodule(gil_used = false)]
 pub mod pyclasses {
     #[cfg(any(Py_3_10, not(Py_LIMITED_API)))]
@@ -111,6 +149,7 @@ pub mod pyclasses {
     use super::ClassWithDict;
     #[pymodule_export]
     use super::{
-        AssertingBaseClass, ClassWithoutConstructor, EmptyClass, PyClassIter, PyClassThreadIter,
+        AssertingBaseClass, ClassWithDecorators, ClassWithoutConstructor, EmptyClass, PyClassIter,
+        PyClassThreadIter,
     };
 }
diff --git a/pytests/src/pyfunctions.rs b/pytests/src/pyfunctions.rs
index 024641d3d2e..19e30712909 100644
--- a/pytests/src/pyfunctions.rs
+++ b/pytests/src/pyfunctions.rs
@@ -67,13 +67,21 @@ fn args_kwargs<'py>(
     (args, kwargs)
 }
 
-#[pymodule(gil_used = false)]
-pub fn pyfunctions(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_function(wrap_pyfunction!(none, m)?)?;
-    m.add_function(wrap_pyfunction!(simple, m)?)?;
-    m.add_function(wrap_pyfunction!(simple_args, m)?)?;
-    m.add_function(wrap_pyfunction!(simple_kwargs, m)?)?;
-    m.add_function(wrap_pyfunction!(simple_args_kwargs, m)?)?;
-    m.add_function(wrap_pyfunction!(args_kwargs, m)?)?;
-    Ok(())
+#[pyfunction(signature = (a, /, b))]
+fn positional_only<'py>(a: Any<'py>, b: Any<'py>) -> (Any<'py>, Any<'py>) {
+    (a, b)
+}
+
+#[pyfunction(signature = (a = false, b = 0, c = 0.0, d = ""))]
+fn with_typed_args(a: bool, b: u64, c: f64, d: &str) -> (bool, u64, f64, &str) {
+    (a, b, c, d)
+}
+
+#[pymodule]
+pub mod pyfunctions {
+    #[pymodule_export]
+    use super::{
+        args_kwargs, none, positional_only, simple, simple_args, simple_args_kwargs, simple_kwargs,
+        with_typed_args,
+    };
 }
diff --git a/pytests/stubs/pyclasses.pyi b/pytests/stubs/pyclasses.pyi
index 2a36e0b4540..13b52f1c4e2 100644
--- a/pytests/stubs/pyclasses.pyi
+++ b/pytests/stubs/pyclasses.pyi
@@ -1,5 +1,31 @@
-class AssertingBaseClass: ...
+class AssertingBaseClass:
+    def __new__(cls, /, expected_type): ...
+
+class ClassWithDecorators:
+    def __new__(cls, /): ...
+    @property
+    def attr(self, /): ...
+    @attr.setter
+    def attr(self, /, value): ...
+    @classmethod
+    @property
+    def cls_attribute(cls, /): ...
+    @classmethod
+    def cls_method(cls, /): ...
+    @staticmethod
+    def static_method(): ...
+
 class ClassWithoutConstructor: ...
-class EmptyClass: ...
-class PyClassIter: ...
-class PyClassThreadIter: ...
+
+class EmptyClass:
+    def __len__(self, /): ...
+    def __new__(cls, /): ...
+    def method(self, /): ...
+
+class PyClassIter:
+    def __new__(cls, /): ...
+    def __next__(self, /): ...
+
+class PyClassThreadIter:
+    def __new__(cls, /): ...
+    def __next__(self, /): ...
diff --git a/pytests/stubs/pyfunctions.pyi b/pytests/stubs/pyfunctions.pyi
index e69de29bb2d..5fb5e6c474c 100644
--- a/pytests/stubs/pyfunctions.pyi
+++ b/pytests/stubs/pyfunctions.pyi
@@ -0,0 +1,8 @@
+def args_kwargs(*args, **kwargs): ...
+def none(): ...
+def positional_only(a, /, b): ...
+def simple(a, b=None, *, c=None): ...
+def simple_args(a, b=None, *args, c=None): ...
+def simple_args_kwargs(a, b=None, *args, c=None, **kwargs): ...
+def simple_kwargs(a, b=None, c=None, **kwargs): ...
+def with_typed_args(a=False, b=0, c=0.0, d=""): ...
diff --git a/pytests/tests/test_pyclasses.py b/pytests/tests/test_pyclasses.py
index 9f611b634b6..a641c9770a4 100644
--- a/pytests/tests/test_pyclasses.py
+++ b/pytests/tests/test_pyclasses.py
@@ -121,3 +121,32 @@ def test_dict():
 
     d.foo = 42
     assert d.__dict__ == {"foo": 42}
+
+
+def test_getter(benchmark):
+    obj = pyclasses.ClassWithDecorators()
+    benchmark(lambda: obj.attr)
+
+
+def test_setter(benchmark):
+    obj = pyclasses.ClassWithDecorators()
+
+    def set_attr():
+        obj.attr = 42
+
+    benchmark(set_attr)
+
+
+def test_class_attribute(benchmark):
+    cls = pyclasses.ClassWithDecorators
+    benchmark(lambda: cls.cls_attribute)
+
+
+def test_class_method(benchmark):
+    cls = pyclasses.ClassWithDecorators
+    benchmark(lambda: cls.cls_method())
+
+
+def test_static_method(benchmark):
+    cls = pyclasses.ClassWithDecorators
+    benchmark(lambda: cls.static_method())
diff --git a/pytests/tests/test_pyfunctions.py b/pytests/tests/test_pyfunctions.py
index c6fb448248b..b3897f289c6 100644
--- a/pytests/tests/test_pyfunctions.py
+++ b/pytests/tests/test_pyfunctions.py
@@ -1,3 +1,5 @@
+from typing import Tuple
+
 from pyo3_pytests import pyfunctions
 
 
@@ -58,7 +60,7 @@ def test_simple_kwargs_rs(benchmark):
 
 
 def simple_args_kwargs_py(a, b=None, *args, c=None, **kwargs):
-    return (a, b, args, c, kwargs)
+    return a, b, args, c, kwargs
 
 
 def test_simple_args_kwargs_py(benchmark):
@@ -72,7 +74,7 @@ def test_simple_args_kwargs_rs(benchmark):
 
 
 def args_kwargs_py(*args, **kwargs):
-    return (args, kwargs)
+    return args, kwargs
 
 
 def test_args_kwargs_py(benchmark):
@@ -83,3 +85,36 @@ def test_args_kwargs_rs(benchmark):
     rust = benchmark(pyfunctions.args_kwargs, 1, "foo", {1: 2}, bar=4, foo=10)
     py = args_kwargs_py(1, "foo", {1: 2}, bar=4, foo=10)
     assert rust == py
+
+
+# TODO: the second argument should be positional-only
+# but can't be without breaking tests on Python 3.7.
+# See gh-5095.
+def positional_only_py(a, b):
+    return a, b
+
+
+def test_positional_only_py(benchmark):
+    benchmark(positional_only_py, 1, "foo")
+
+
+def test_positional_only_rs(benchmark):
+    rust = benchmark(pyfunctions.positional_only, 1, "foo")
+    py = positional_only_py(1, "foo")
+    assert rust == py
+
+
+def with_typed_args_py(
+    a: bool, b: int, c: float, d: str
+) -> Tuple[bool, int, float, str]:
+    return a, b, c, d
+
+
+def test_with_typed_args_py(benchmark):
+    benchmark(with_typed_args_py, True, 1, 1.2, "foo")
+
+
+def test_with_typed_args_rs(benchmark):
+    rust = benchmark(pyfunctions.with_typed_args, True, 1, 1.2, "foo")
+    py = with_typed_args_py(True, 1, 1.2, "foo")
+    assert rust == py
diff --git a/src/buffer.rs b/src/buffer.rs
index c5e5de568eb..6f74b698de7 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -702,7 +702,7 @@ mod tests {
                 buffer.0.suboffsets,
                 buffer.0.internal
             );
-            let debug_repr = format!("{:?}", buffer);
+            let debug_repr = format!("{buffer:?}");
             assert_eq!(debug_repr, expected);
         });
     }
@@ -829,8 +829,7 @@ mod tests {
             assert_eq!(
                 ElementType::from_format(cstr),
                 expected,
-                "element from format &Cstr: {:?}",
-                cstr,
+                "element from format &Cstr: {cstr:?}",
             );
         }
     }
diff --git a/src/conversion.rs b/src/conversion.rs
index 53c9f3a9de8..165175fae54 100644
--- a/src/conversion.rs
+++ b/src/conversion.rs
@@ -5,67 +5,9 @@ use crate::inspect::types::TypeInfo;
 use crate::pyclass::boolean_struct::False;
 use crate::types::any::PyAnyMethods;
 use crate::types::PyTuple;
-use crate::{
-    ffi, Borrowed, Bound, BoundObject, Py, PyAny, PyClass, PyErr, PyRef, PyRefMut, Python,
-};
+use crate::{Borrowed, Bound, BoundObject, Py, PyAny, PyClass, PyErr, PyRef, PyRefMut, Python};
 use std::convert::Infallible;
 
-/// Returns a borrowed pointer to a Python object.
-///
-/// The returned pointer will be valid for as long as `self` is. It may be null depending on the
-/// implementation.
-///
-/// # Examples
-///
-/// ```rust
-/// use pyo3::prelude::*;
-/// use pyo3::ffi;
-///
-/// Python::with_gil(|py| {
-///     let s = "foo".into_pyobject(py)?;
-///     let ptr = s.as_ptr();
-///
-///     let is_really_a_pystring = unsafe { ffi::PyUnicode_CheckExact(ptr) };
-///     assert_eq!(is_really_a_pystring, 1);
-/// #   Ok::<_, PyErr>(())
-/// })
-/// # .unwrap();
-/// ```
-///
-/// # Safety
-///
-/// For callers, it is your responsibility to make sure that the underlying Python object is not dropped too
-/// early. For example, the following code will cause undefined behavior:
-///
-/// ```rust,no_run
-/// # use pyo3::prelude::*;
-/// # use pyo3::ffi;
-/// #
-/// Python::with_gil(|py| {
-///     // ERROR: calling `.as_ptr()` will throw away the temporary object and leave `ptr` dangling.
-///     let ptr: *mut ffi::PyObject = 0xabad1dea_u32.into_pyobject(py)?.as_ptr();
-///
-///     let isnt_a_pystring = unsafe {
-///         // `ptr` is dangling, this is UB
-///         ffi::PyUnicode_CheckExact(ptr)
-///     };
-/// #   assert_eq!(isnt_a_pystring, 0);
-/// #   Ok::<_, PyErr>(())
-/// })
-/// # .unwrap();
-/// ```
-///
-/// This happens because the pointer returned by `as_ptr` does not carry any lifetime information
-/// and the Python object is dropped immediately after the `0xabad1dea_u32.into_pyobject(py).as_ptr()`
-/// expression is evaluated. To fix the problem, bind Python object to a local variable like earlier
-/// to keep the Python object alive until the end of its scope.
-///
-/// Implementors must ensure this returns a valid pointer to a Python object, which borrows a reference count from `&self`.
-pub unsafe trait AsPyPointer {
-    /// Returns the underlying FFI pointer as a borrowed pointer.
-    fn as_ptr(&self) -> *mut ffi::PyObject;
-}
-
 /// Defines a conversion from a Rust type to a Python object, which may fail.
 ///
 /// This trait has `#[derive(IntoPyObject)]` to automatically implement it for simple types and
diff --git a/src/conversions/anyhow.rs b/src/conversions/anyhow.rs
index d2cb3f3eb60..0bf346d835a 100644
--- a/src/conversions/anyhow.rs
+++ b/src/conversions/anyhow.rs
@@ -113,7 +113,7 @@ impl From<anyhow::Error> for PyErr {
                 Err(error) => error,
             };
         }
-        PyRuntimeError::new_err(format!("{:?}", error))
+        PyRuntimeError::new_err(format!("{error:?}"))
     }
 }
 
@@ -141,7 +141,7 @@ mod test_anyhow {
     #[test]
     fn test_pyo3_exception_contents() {
         let err = h().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
         Python::with_gil(|py| {
@@ -160,7 +160,7 @@ mod test_anyhow {
     #[test]
     fn test_pyo3_exception_contents2() {
         let err = k().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
         Python::with_gil(|py| {
diff --git a/src/conversions/bigdecimal.rs b/src/conversions/bigdecimal.rs
index 446e38bf6c5..129def772c8 100644
--- a/src/conversions/bigdecimal.rs
+++ b/src/conversions/bigdecimal.rs
@@ -161,8 +161,7 @@ mod test_bigdecimal {
                 locals.set_item("rs_dec", &rs_dec).unwrap();
                 py.run(
                     &CString::new(format!(
-                       "import decimal\npy_dec = decimal.Decimal(\"{}\")\nassert py_dec == rs_dec",
-                     num)).unwrap(),
+                       "import decimal\npy_dec = decimal.Decimal(\"{num}\")\nassert py_dec == rs_dec")).unwrap(),
                 None, Some(&locals)).unwrap();
                 let roundtripped: BigDecimal = rs_dec.extract().unwrap();
                 assert_eq!(num, roundtripped);
diff --git a/src/conversions/chrono.rs b/src/conversions/chrono.rs
index fb8890d696a..bf99951e459 100644
--- a/src/conversions/chrono.rs
+++ b/src/conversions/chrono.rs
@@ -47,13 +47,10 @@ use crate::exceptions::{PyTypeError, PyUserWarning, PyValueError};
 use crate::intern;
 use crate::types::any::PyAnyMethods;
 use crate::types::PyNone;
-use crate::types::{
-    datetime::timezone_from_offset, timezone_utc, PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo,
-    PyTzInfoAccess,
-};
+use crate::types::{PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo, PyTzInfoAccess};
 #[cfg(not(Py_LIMITED_API))]
 use crate::types::{PyDateAccess, PyDeltaAccess, PyTimeAccess};
-use crate::{ffi, Bound, FromPyObject, IntoPyObjectExt, PyAny, PyErr, PyResult, Python};
+use crate::{ffi, Borrowed, Bound, FromPyObject, IntoPyObjectExt, PyAny, PyErr, PyResult, Python};
 use chrono::offset::{FixedOffset, Utc};
 use chrono::{
     DateTime, Datelike, Duration, LocalResult, NaiveDate, NaiveDateTime, NaiveTime, Offset,
@@ -348,8 +345,7 @@ impl<Tz: TimeZone + for<'py> FromPyObject<'py>> FromPyObject<'_> for DateTime<Tz
                 }
             }
             LocalResult::None => Err(PyValueError::new_err(format!(
-                "The datetime {:?} contains an incompatible timezone",
-                dt
+                "The datetime {dt:?} contains an incompatible timezone"
             ))),
         }
     }
@@ -363,7 +359,7 @@ impl<'py> IntoPyObject<'py> for FixedOffset {
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         let seconds_offset = self.local_minus_utc();
         let td = PyDelta::new(py, 0, seconds_offset, 0, true)?;
-        timezone_from_offset(&td)
+        PyTzInfo::fixed_offset(py, td)
     }
 }
 
@@ -394,8 +390,7 @@ impl FromPyObject<'_> for FixedOffset {
         let py_timedelta = ob.call_method1("utcoffset", (PyNone::get(ob.py()),))?;
         if py_timedelta.is_none() {
             return Err(PyTypeError::new_err(format!(
-                "{:?} is not a fixed offset timezone",
-                ob
+                "{ob:?} is not a fixed offset timezone"
             )));
         }
         let total_seconds: Duration = py_timedelta.extract()?;
@@ -408,17 +403,17 @@ impl FromPyObject<'_> for FixedOffset {
 
 impl<'py> IntoPyObject<'py> for Utc {
     type Target = PyTzInfo;
-    type Output = Bound<'py, Self::Target>;
+    type Output = Borrowed<'static, 'py, Self::Target>;
     type Error = PyErr;
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
-        Ok(timezone_utc(py))
+        PyTzInfo::utc(py)
     }
 }
 
 impl<'py> IntoPyObject<'py> for &Utc {
     type Target = PyTzInfo;
-    type Output = Bound<'py, Self::Target>;
+    type Output = Borrowed<'static, 'py, Self::Target>;
     type Error = PyErr;
 
     #[inline]
@@ -429,7 +424,7 @@ impl<'py> IntoPyObject<'py> for &Utc {
 
 impl FromPyObject<'_> for Utc {
     fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Utc> {
-        let py_utc = timezone_utc(ob.py());
+        let py_utc = PyTzInfo::utc(ob.py())?;
         if ob.eq(py_utc)? {
             Ok(Utc)
         } else {
@@ -662,10 +657,7 @@ mod tests {
                 let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
                 assert!(
                     delta.eq(&py_delta).unwrap(),
-                    "{}: {} != {}",
-                    name,
-                    delta,
-                    py_delta
+                    "{name}: {delta} != {py_delta}"
                 );
             });
         };
@@ -701,7 +693,7 @@ mod tests {
             Python::with_gil(|py| {
                 let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
                 let py_delta: Duration = py_delta.extract().unwrap();
-                assert_eq!(py_delta, delta, "{}: {} != {}", name, py_delta, delta);
+                assert_eq!(py_delta, delta, "{name}: {py_delta} != {delta}");
             })
         };
 
@@ -764,10 +756,7 @@ mod tests {
                 assert_eq!(
                     date.compare(&py_date).unwrap(),
                     Ordering::Equal,
-                    "{}: {} != {}",
-                    name,
-                    date,
-                    py_date
+                    "{name}: {date} != {py_date}"
                 );
             })
         };
@@ -785,7 +774,7 @@ mod tests {
                 let py_date = new_py_datetime_ob(py, "date", (year, month, day));
                 let py_date: NaiveDate = py_date.extract().unwrap();
                 let date = NaiveDate::from_ymd_opt(year, month, day).unwrap();
-                assert_eq!(py_date, date, "{}: {} != {}", name, date, py_date);
+                assert_eq!(py_date, date, "{name}: {date} != {py_date}");
             })
         };
 
@@ -823,10 +812,7 @@ mod tests {
                     assert_eq!(
                         datetime.compare(&py_datetime).unwrap(),
                         Ordering::Equal,
-                        "{}: {} != {}",
-                        name,
-                        datetime,
-                        py_datetime
+                        "{name}: {datetime} != {py_datetime}"
                     );
                 };
 
@@ -866,10 +852,7 @@ mod tests {
                     assert_eq!(
                         datetime.compare(&py_datetime).unwrap(),
                         Ordering::Equal,
-                        "{}: {} != {}",
-                        name,
-                        datetime,
-                        py_datetime
+                        "{name}: {datetime} != {py_datetime}"
                     );
                 };
 
@@ -926,7 +909,7 @@ mod tests {
             let minute = 8;
             let second = 9;
             let micro = 999_999;
-            let tz_utc = timezone_utc(py);
+            let tz_utc = PyTzInfo::utc(py).unwrap();
             let py_datetime = new_py_datetime_ob(
                 py,
                 "datetime",
@@ -1056,13 +1039,7 @@ mod tests {
                     .into_pyobject(py)
                     .unwrap();
                 let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, py_ms));
-                assert!(
-                    time.eq(&py_time).unwrap(),
-                    "{}: {} != {}",
-                    name,
-                    time,
-                    py_time
-                );
+                assert!(time.eq(&py_time).unwrap(), "{name}: {time} != {py_time}");
             };
 
             check_time("regular", 3, 5, 7, 999_999, 999_999);
@@ -1145,7 +1122,7 @@ mod tests {
                 Python::with_gil(|py| {
 
                     let globals = [("datetime", py.import("datetime").unwrap())].into_py_dict(py).unwrap();
-                    let code = format!("datetime.datetime.fromtimestamp({}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={})))", timestamp, timedelta);
+                    let code = format!("datetime.datetime.fromtimestamp({timestamp}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={timedelta})))");
                     let t = py.eval(&CString::new(code).unwrap(), Some(&globals), None).unwrap();
 
                     // Get ISO 8601 string from python
diff --git a/src/conversions/chrono_tz.rs b/src/conversions/chrono_tz.rs
index d564bcca87b..e8e5dc60e7a 100644
--- a/src/conversions/chrono_tz.rs
+++ b/src/conversions/chrono_tz.rs
@@ -37,27 +37,23 @@
 use crate::conversion::IntoPyObject;
 use crate::exceptions::PyValueError;
 use crate::pybacked::PyBackedStr;
-use crate::sync::GILOnceCell;
-use crate::types::{any::PyAnyMethods, PyType};
-use crate::{intern, Bound, FromPyObject, Py, PyAny, PyErr, PyResult, Python};
+use crate::types::{any::PyAnyMethods, PyTzInfo};
+use crate::{intern, Bound, FromPyObject, PyAny, PyErr, PyResult, Python};
 use chrono_tz::Tz;
 use std::str::FromStr;
 
 impl<'py> IntoPyObject<'py> for Tz {
-    type Target = PyAny;
+    type Target = PyTzInfo;
     type Output = Bound<'py, Self::Target>;
     type Error = PyErr;
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
-        static ZONE_INFO: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-        ZONE_INFO
-            .import(py, "zoneinfo", "ZoneInfo")
-            .and_then(|obj| obj.call1((self.name(),)))
+        PyTzInfo::timezone(py, self.name())
     }
 }
 
 impl<'py> IntoPyObject<'py> for &Tz {
-    type Target = PyAny;
+    type Target = PyTzInfo;
     type Output = Bound<'py, Self::Target>;
     type Error = PyErr;
 
@@ -81,6 +77,7 @@ impl FromPyObject<'_> for Tz {
 mod tests {
     use super::*;
     use crate::prelude::PyAnyMethods;
+    use crate::types::PyTzInfo;
     use crate::Python;
     use chrono::{DateTime, Utc};
     use chrono_tz::Tz;
@@ -152,8 +149,8 @@ mod tests {
     #[cfg(not(Py_GIL_DISABLED))] // https://github.com/python/cpython/issues/116738#issuecomment-2404360445
     fn test_into_pyobject() {
         Python::with_gil(|py| {
-            let assert_eq = |l: Bound<'_, PyAny>, r: Bound<'_, PyAny>| {
-                assert!(l.eq(&r).unwrap(), "{:?} != {:?}", l, r);
+            let assert_eq = |l: Bound<'_, PyTzInfo>, r: Bound<'_, PyTzInfo>| {
+                assert!(l.eq(&r).unwrap(), "{l:?} != {r:?}");
             };
 
             assert_eq(
@@ -168,11 +165,7 @@ mod tests {
         });
     }
 
-    fn new_zoneinfo<'py>(py: Python<'py>, name: &str) -> Bound<'py, PyAny> {
-        zoneinfo_class(py).call1((name,)).unwrap()
-    }
-
-    fn zoneinfo_class(py: Python<'_>) -> Bound<'_, PyAny> {
-        py.import("zoneinfo").unwrap().getattr("ZoneInfo").unwrap()
+    fn new_zoneinfo<'py>(py: Python<'py>, name: &str) -> Bound<'py, PyTzInfo> {
+        PyTzInfo::timezone(py, name).unwrap()
     }
 }
diff --git a/src/conversions/eyre.rs b/src/conversions/eyre.rs
index 42d7a12c872..4a501de9c69 100644
--- a/src/conversions/eyre.rs
+++ b/src/conversions/eyre.rs
@@ -119,7 +119,7 @@ impl From<eyre::Report> for PyErr {
                 Err(error) => error,
             };
         }
-        PyRuntimeError::new_err(format!("{:?}", error))
+        PyRuntimeError::new_err(format!("{error:?}"))
     }
 }
 
@@ -147,7 +147,7 @@ mod tests {
     #[test]
     fn test_pyo3_exception_contents() {
         let err = h().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
         Python::with_gil(|py| {
@@ -166,7 +166,7 @@ mod tests {
     #[test]
     fn test_pyo3_exception_contents2() {
         let err = k().unwrap_err();
-        let expected_contents = format!("{:?}", err);
+        let expected_contents = format!("{err:?}");
         let pyerr = PyErr::from(err);
 
         Python::with_gil(|py| {
diff --git a/src/conversions/jiff.rs b/src/conversions/jiff.rs
index 2b90686844a..814040e5fb4 100644
--- a/src/conversions/jiff.rs
+++ b/src/conversions/jiff.rs
@@ -48,15 +48,11 @@
 //! ```
 use crate::exceptions::{PyTypeError, PyValueError};
 use crate::pybacked::PyBackedStr;
-use crate::sync::GILOnceCell;
-use crate::types::{
-    datetime::timezone_from_offset, timezone_utc, PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo,
-    PyTzInfoAccess,
-};
-use crate::types::{PyAnyMethods, PyNone, PyType};
+use crate::types::{PyAnyMethods, PyNone};
+use crate::types::{PyDate, PyDateTime, PyDelta, PyTime, PyTzInfo, PyTzInfoAccess};
 #[cfg(not(Py_LIMITED_API))]
 use crate::types::{PyDateAccess, PyDeltaAccess, PyTimeAccess};
-use crate::{intern, Bound, FromPyObject, IntoPyObject, Py, PyAny, PyErr, PyResult, Python};
+use crate::{intern, Bound, FromPyObject, IntoPyObject, PyAny, PyErr, PyResult, Python};
 use jiff::civil::{Date, DateTime, Time};
 use jiff::tz::{Offset, TimeZone};
 use jiff::{SignedDuration, Span, Timestamp, Zoned};
@@ -278,6 +274,7 @@ impl<'py> IntoPyObject<'py> for &Zoned {
             };
             Some(zoned.timestamp() + (zoned.offset() - prev.offset()) <= start_of_current_offset)
         }
+
         datetime_to_pydatetime(
             py,
             &self.datetime(),
@@ -333,17 +330,14 @@ impl<'py> IntoPyObject<'py> for &TimeZone {
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         if self == &TimeZone::UTC {
-            Ok(timezone_utc(py))
-        } else if let Some(iana_name) = self.iana_name() {
-            static ZONE_INFO: GILOnceCell<Py<PyType>> = GILOnceCell::new();
-            let tz = ZONE_INFO
-                .import(py, "zoneinfo", "ZoneInfo")
-                .and_then(|obj| obj.call1((iana_name,)))?
-                .downcast_into()?;
-            Ok(tz)
-        } else {
-            self.to_fixed_offset()?.into_pyobject(py)
+            return Ok(PyTzInfo::utc(py)?.to_owned());
+        }
+
+        if let Some(iana_name) = self.iana_name() {
+            return PyTzInfo::timezone(py, iana_name);
         }
+
+        self.to_fixed_offset()?.into_pyobject(py)
     }
 }
 
@@ -367,12 +361,10 @@ impl<'py> IntoPyObject<'py> for &Offset {
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         if self == &Offset::UTC {
-            return Ok(timezone_utc(py));
+            return Ok(PyTzInfo::utc(py)?.to_owned());
         }
 
-        let delta = self.duration_since(Offset::UTC).into_pyobject(py)?;
-
-        timezone_from_offset(&delta)
+        PyTzInfo::fixed_offset(py, self.duration_since(Offset::UTC))
     }
 }
 
@@ -394,8 +386,7 @@ impl<'py> FromPyObject<'py> for Offset {
         let py_timedelta = ob.call_method1(intern!(py, "utcoffset"), (PyNone::get(py),))?;
         if py_timedelta.is_none() {
             return Err(PyTypeError::new_err(format!(
-                "{:?} is not a fixed offset timezone",
-                ob
+                "{ob:?} is not a fixed offset timezone"
             )));
         }
 
@@ -476,8 +467,6 @@ impl From<jiff::Error> for PyErr {
 #[cfg(test)]
 mod tests {
     use super::*;
-    #[cfg(not(Py_LIMITED_API))]
-    use crate::types::timezone_utc;
     use crate::{types::PyTuple, BoundObject};
     use jiff::tz::Offset;
     use std::cmp::Ordering;
@@ -586,10 +575,7 @@ mod tests {
                 assert_eq!(
                     date.compare(&py_date).unwrap(),
                     Ordering::Equal,
-                    "{}: {} != {}",
-                    name,
-                    date,
-                    py_date
+                    "{name}: {date} != {py_date}"
                 );
             })
         };
@@ -607,7 +593,7 @@ mod tests {
                 let py_date = new_py_datetime_ob(py, "date", (year, month, day));
                 let py_date: Date = py_date.extract().unwrap();
                 let date = Date::new(year, month, day).unwrap();
-                assert_eq!(py_date, date, "{}: {} != {}", name, date, py_date);
+                assert_eq!(py_date, date, "{name}: {date} != {py_date}");
             })
         };
 
@@ -644,10 +630,7 @@ mod tests {
                     assert_eq!(
                         datetime.compare(&py_datetime).unwrap(),
                         Ordering::Equal,
-                        "{}: {} != {}",
-                        name,
-                        datetime,
-                        py_datetime
+                        "{name}: {datetime} != {py_datetime}"
                     );
                 };
 
@@ -663,7 +646,7 @@ mod tests {
                     let offset = Offset::from_seconds(3600).unwrap();
                     let datetime = DateTime::new(year, month, day, hour, minute, second, ms * 1000)
                         .map_err(|e| {
-                            eprintln!("{}: {}", name, e);
+                            eprintln!("{name}: {e}");
                             e
                         })
                         .unwrap()
@@ -679,10 +662,7 @@ mod tests {
                     assert_eq!(
                         datetime.compare(&py_datetime).unwrap(),
                         Ordering::Equal,
-                        "{}: {} != {}",
-                        name,
-                        datetime,
-                        py_datetime
+                        "{name}: {datetime} != {py_datetime}"
                     );
                 };
 
@@ -727,7 +707,7 @@ mod tests {
             let minute = 8;
             let second = 9;
             let micro = 999_999;
-            let tz_utc = timezone_utc(py);
+            let tz_utc = PyTzInfo::utc(py).unwrap();
             let py_datetime = new_py_datetime_ob(
                 py,
                 "datetime",
@@ -893,13 +873,7 @@ mod tests {
                     .into_pyobject(py)
                     .unwrap();
                 let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, py_ms));
-                assert!(
-                    time.eq(&py_time).unwrap(),
-                    "{}: {} != {}",
-                    name,
-                    time,
-                    py_time
-                );
+                assert!(time.eq(&py_time).unwrap(), "{name}: {time} != {py_time}");
             };
 
             check_time("regular", 3, 5, 7, 999_999, 999_999);
@@ -1001,7 +975,7 @@ mod tests {
                 Python::with_gil(|py| {
 
                     let globals = [("datetime", py.import("datetime").unwrap())].into_py_dict(py).unwrap();
-                    let code = format!("datetime.datetime.fromtimestamp({}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={})))", timestamp, timedelta);
+                    let code = format!("datetime.datetime.fromtimestamp({timestamp}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={timedelta})))");
                     let t = py.eval(&CString::new(code).unwrap(), Some(&globals), None).unwrap();
 
                     // Get ISO 8601 string from python
diff --git a/src/conversions/mod.rs b/src/conversions/mod.rs
index 0afd39745c9..c623ca7b379 100644
--- a/src/conversions/mod.rs
+++ b/src/conversions/mod.rs
@@ -12,8 +12,10 @@ pub mod jiff;
 pub mod num_bigint;
 pub mod num_complex;
 pub mod num_rational;
+pub mod ordered_float;
 pub mod rust_decimal;
 pub mod serde;
 pub mod smallvec;
 mod std;
+pub mod time;
 pub mod uuid;
diff --git a/src/conversions/ordered_float.rs b/src/conversions/ordered_float.rs
new file mode 100644
index 00000000000..79bce2c66c1
--- /dev/null
+++ b/src/conversions/ordered_float.rs
@@ -0,0 +1,330 @@
+#![cfg(feature = "ordered-float")]
+//! Conversions to and from [ordered-float](https://docs.rs/ordered-float) types.
+//! [`NotNan`]`<`[`f32`]`>` and [`NotNan`]`<`[`f64`]`>`.
+//! [`OrderedFloat`]`<`[`f32`]`>` and [`OrderedFloat`]`<`[`f64`]`>`.
+//!
+//! This is useful for converting between Python's float into and from a native Rust type.
+//!
+//! Take care when comparing sorted collections of float types between Python and Rust.
+//! They will likely differ due to the ambiguous sort order of NaNs in Python.
+//
+//!
+//! To use this feature, add to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"ordered-float\"] }")]
+//! ordered-float = "5.0.0"
+//! ```
+//!
+//! # Example
+//!
+//! Rust code to create functions that add ordered floats:
+//!
+//! ```rust,no_run
+//! use ordered_float::{NotNan, OrderedFloat};
+//! use pyo3::prelude::*;
+//!
+//! #[pyfunction]
+//! fn add_not_nans(a: NotNan<f64>, b: NotNan<f64>) -> NotNan<f64> {
+//!     a + b
+//! }
+//!
+//! #[pyfunction]
+//! fn add_ordered_floats(a: OrderedFloat<f64>, b: OrderedFloat<f64>) -> OrderedFloat<f64> {
+//!     a + b
+//! }
+//!
+//! #[pymodule]
+//! fn my_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
+//!     m.add_function(wrap_pyfunction!(add_not_nans, m)?)?;
+//!     m.add_function(wrap_pyfunction!(add_ordered_floats, m)?)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Python code that validates the functionality:
+//! ```python
+//! from my_module import add_not_nans, add_ordered_floats
+//!
+//! assert add_not_nans(1.0,2.0) == 3.0
+//! assert add_ordered_floats(1.0,2.0) == 3.0
+//! ```
+
+use crate::conversion::IntoPyObject;
+use crate::exceptions::PyValueError;
+use crate::types::{any::PyAnyMethods, PyFloat};
+use crate::{Bound, FromPyObject, PyAny, PyResult, Python};
+use ordered_float::{NotNan, OrderedFloat};
+use std::convert::Infallible;
+
+macro_rules! float_conversions {
+    ($wrapper:ident, $float_type:ty, $constructor:expr) => {
+        impl FromPyObject<'_> for $wrapper<$float_type> {
+            fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
+                let val: $float_type = obj.extract()?;
+                $constructor(val)
+            }
+        }
+
+        impl<'py> IntoPyObject<'py> for $wrapper<$float_type> {
+            type Target = PyFloat;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                self.into_inner().into_pyobject(py)
+            }
+        }
+
+        impl<'py> IntoPyObject<'py> for &$wrapper<$float_type> {
+            type Target = PyFloat;
+            type Output = Bound<'py, Self::Target>;
+            type Error = Infallible;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
+            }
+        }
+    };
+}
+float_conversions!(OrderedFloat, f32, |val| Ok(OrderedFloat(val)));
+float_conversions!(OrderedFloat, f64, |val| Ok(OrderedFloat(val)));
+float_conversions!(NotNan, f32, |val| NotNan::new(val)
+    .map_err(|e| PyValueError::new_err(e.to_string())));
+float_conversions!(NotNan, f64, |val| NotNan::new(val)
+    .map_err(|e| PyValueError::new_err(e.to_string())));
+
+#[cfg(test)]
+mod test_ordered_float {
+    use super::*;
+    use crate::ffi::c_str;
+    use crate::py_run;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    use proptest::prelude::*;
+
+    macro_rules! float_roundtrip_tests {
+        ($wrapper:ident, $float_type:ty, $constructor:expr, $standard_test:ident, $wasm_test:ident, $infinity_test:ident, $zero_test:ident) => {
+            #[cfg(not(target_arch = "wasm32"))]
+            proptest! {
+            #[test]
+            fn $standard_test(inner_f: $float_type) {
+                let f = $constructor(inner_f);
+
+                Python::with_gil(|py| {
+                    let f_py: Bound<'_, PyFloat>  = f.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        f_py,
+                        &format!(
+                            "import math\nassert math.isclose(f_py, {})",
+                             inner_f as f64 // Always interpret the literal rs float value as f64
+                                            // so that it's comparable with the python float
+                        )
+                    );
+
+                    let roundtripped_f: $wrapper<$float_type> = f_py.extract().unwrap();
+
+                    assert_eq!(f, roundtripped_f);
+                })
+            }
+            }
+
+            #[cfg(target_arch = "wasm32")]
+            #[test]
+            fn $wasm_test() {
+                let inner_f = 10.0;
+                let f = $constructor(inner_f);
+
+                Python::with_gil(|py| {
+                    let f_py: Bound<'_, PyFloat>  = f.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        f_py,
+                        &format!(
+                            "import math\nassert math.isclose(f_py, {})",
+                            inner_f as f64 // Always interpret the literal rs float value as f64
+                                           // so that it's comparable with the python float
+                        )
+                    );
+
+                    let roundtripped_f: $wrapper<$float_type> = f_py.extract().unwrap();
+
+                    assert_eq!(f, roundtripped_f);
+                })
+            }
+
+            #[test]
+            fn $infinity_test() {
+                let inner_pinf = <$float_type>::INFINITY;
+                let pinf = $constructor(inner_pinf);
+
+                let inner_ninf = <$float_type>::NEG_INFINITY;
+                let ninf = $constructor(inner_ninf);
+
+                Python::with_gil(|py| {
+                    let pinf_py: Bound<'_, PyFloat>  = pinf.into_pyobject(py).unwrap();
+                    let ninf_py: Bound<'_, PyFloat>  = ninf.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        pinf_py ninf_py,
+                        "\
+                        assert pinf_py == float('inf')\n\
+                        assert ninf_py == float('-inf')"
+                    );
+
+                    let roundtripped_pinf: $wrapper<$float_type> = pinf_py.extract().unwrap();
+                    let roundtripped_ninf: $wrapper<$float_type> = ninf_py.extract().unwrap();
+
+                    assert_eq!(pinf, roundtripped_pinf);
+                    assert_eq!(ninf, roundtripped_ninf);
+                })
+            }
+
+            #[test]
+            fn $zero_test() {
+                let inner_pzero: $float_type = 0.0;
+                let pzero = $constructor(inner_pzero);
+
+                let inner_nzero: $float_type = -0.0;
+                let nzero = $constructor(inner_nzero);
+
+                Python::with_gil(|py| {
+                    let pzero_py: Bound<'_, PyFloat>  = pzero.into_pyobject(py).unwrap();
+                    let nzero_py: Bound<'_, PyFloat>  = nzero.into_pyobject(py).unwrap();
+
+                    // This python script verifies that the values are 0.0 in magnitude
+                    // and that the signs are correct(+0.0 vs -0.0)
+                    py_run!(
+                        py,
+                        pzero_py nzero_py,
+                        "\
+                        import math\n\
+                        assert pzero_py == 0.0\n\
+                        assert math.copysign(1.0, pzero_py) > 0.0\n\
+                        assert nzero_py == 0.0\n\
+                        assert math.copysign(1.0, nzero_py) < 0.0"
+                    );
+
+                    let roundtripped_pzero: $wrapper<$float_type> = pzero_py.extract().unwrap();
+                    let roundtripped_nzero: $wrapper<$float_type> = nzero_py.extract().unwrap();
+
+                    assert_eq!(pzero, roundtripped_pzero);
+                    assert_eq!(roundtripped_pzero.signum(), 1.0);
+                    assert_eq!(nzero, roundtripped_nzero);
+                    assert_eq!(roundtripped_nzero.signum(), -1.0);
+                })
+            }
+        };
+    }
+    float_roundtrip_tests!(
+        OrderedFloat,
+        f32,
+        OrderedFloat,
+        ordered_float_f32_standard,
+        ordered_float_f32_wasm,
+        ordered_float_f32_infinity,
+        ordered_float_f32_zero
+    );
+    float_roundtrip_tests!(
+        OrderedFloat,
+        f64,
+        OrderedFloat,
+        ordered_float_f64_standard,
+        ordered_float_f64_wasm,
+        ordered_float_f64_infinity,
+        ordered_float_f64_zero
+    );
+    float_roundtrip_tests!(
+        NotNan,
+        f32,
+        |val| NotNan::new(val).unwrap(),
+        not_nan_f32_standard,
+        not_nan_f32_wasm,
+        not_nan_f32_infinity,
+        not_nan_f32_zero
+    );
+    float_roundtrip_tests!(
+        NotNan,
+        f64,
+        |val| NotNan::new(val).unwrap(),
+        not_nan_f64_standard,
+        not_nan_f64_wasm,
+        not_nan_f64_infinity,
+        not_nan_f64_zero
+    );
+
+    macro_rules! ordered_float_pynan_tests {
+        ($test_name:ident, $float_type:ty) => {
+            #[test]
+            fn $test_name() {
+                let inner_nan: $float_type = <$float_type>::NAN;
+                let nan = OrderedFloat(inner_nan);
+
+                Python::with_gil(|py| {
+                    let nan_py: Bound<'_, PyFloat> = nan.into_pyobject(py).unwrap();
+
+                    py_run!(
+                        py,
+                        nan_py,
+                        "\
+                        import math\n\
+                        assert math.isnan(nan_py)"
+                    );
+
+                    let roundtripped_nan: OrderedFloat<$float_type> = nan_py.extract().unwrap();
+
+                    assert_eq!(nan, roundtripped_nan);
+                })
+            }
+        };
+    }
+    ordered_float_pynan_tests!(test_ordered_float_pynan_f32, f32);
+    ordered_float_pynan_tests!(test_ordered_float_pynan_f64, f64);
+
+    macro_rules! not_nan_pynan_tests {
+        ($test_name:ident, $float_type:ty) => {
+            #[test]
+            fn $test_name() {
+                Python::with_gil(|py| {
+                    let nan_py = py.eval(c_str!("float('nan')"), None, None).unwrap();
+
+                    let nan_rs: PyResult<NotNan<$float_type>> = nan_py.extract();
+
+                    assert!(nan_rs.is_err());
+                })
+            }
+        };
+    }
+    not_nan_pynan_tests!(test_not_nan_pynan_f32, f32);
+    not_nan_pynan_tests!(test_not_nan_pynan_f64, f64);
+
+    macro_rules! py64_rs32 {
+        ($test_name:ident, $wrapper:ident, $float_type:ty) => {
+            #[test]
+            fn $test_name() {
+                Python::with_gil(|py| {
+                    let py_64 = py
+                        .import("sys")
+                        .unwrap()
+                        .getattr("float_info")
+                        .unwrap()
+                        .getattr("max")
+                        .unwrap();
+                    let rs_32 = py_64.extract::<$wrapper<f32>>().unwrap();
+                    // The python f64 is not representable in a rust f32
+                    assert!(rs_32.is_infinite());
+                })
+            }
+        };
+    }
+    py64_rs32!(ordered_float_f32, OrderedFloat, f32);
+    py64_rs32!(ordered_float_f64, OrderedFloat, f64);
+    py64_rs32!(not_nan_f32, NotNan, f32);
+    py64_rs32!(not_nan_f64, NotNan, f64);
+}
diff --git a/src/conversions/rust_decimal.rs b/src/conversions/rust_decimal.rs
index 392971a0b4b..8c5d870a2dd 100644
--- a/src/conversions/rust_decimal.rs
+++ b/src/conversions/rust_decimal.rs
@@ -169,8 +169,7 @@ mod test_rust_decimal {
                 locals.set_item("rs_dec", &rs_dec).unwrap();
                 py.run(
                     &CString::new(format!(
-                       "import decimal\npy_dec = decimal.Decimal(\"{}\")\nassert py_dec == rs_dec",
-                     num)).unwrap(),
+                       "import decimal\npy_dec = decimal.Decimal(\"{num}\")\nassert py_dec == rs_dec")).unwrap(),
                 None, Some(&locals)).unwrap();
                 let roundtripped: Decimal = rs_dec.extract().unwrap();
                 assert_eq!(num, roundtripped);
diff --git a/src/conversions/std/array.rs b/src/conversions/std/array.rs
index 36db5ec640f..1d88965e711 100644
--- a/src/conversions/std/array.rs
+++ b/src/conversions/std/array.rs
@@ -110,8 +110,7 @@ where
 
 fn invalid_sequence_length(expected: usize, actual: usize) -> PyErr {
     exceptions::PyValueError::new_err(format!(
-        "expected a sequence of length {} (got {})",
-        expected, actual
+        "expected a sequence of length {expected} (got {actual})"
     ))
 }
 
diff --git a/src/conversions/std/ipaddr.rs b/src/conversions/std/ipaddr.rs
index 76f6a6927c2..0c479a2d836 100644
--- a/src/conversions/std/ipaddr.rs
+++ b/src/conversions/std/ipaddr.rs
@@ -123,7 +123,7 @@ mod test_ipaddr {
                 let pyobj = ip.into_pyobject(py).unwrap();
                 let repr = pyobj.repr().unwrap();
                 let repr = repr.to_string_lossy();
-                assert_eq!(repr, format!("{}('{}')", py_cls, ip));
+                assert_eq!(repr, format!("{py_cls}('{ip}')"));
 
                 let ip2: IpAddr = pyobj.extract().unwrap();
                 assert_eq!(ip, ip2);
diff --git a/src/conversions/std/num.rs b/src/conversions/std/num.rs
index 40073d8af69..ea5798cac99 100644
--- a/src/conversions/std/num.rs
+++ b/src/conversions/std/num.rs
@@ -606,7 +606,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: i128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
@@ -622,7 +622,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: NonZeroI128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
@@ -637,7 +637,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: u128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
@@ -653,7 +653,7 @@ mod test_128bit_integers {
                 let x_py = x.into_pyobject(py).unwrap();
                 let locals = PyDict::new(py);
                 locals.set_item("x_py", &x_py).unwrap();
-                py.run(&CString::new(format!("assert x_py == {}", x)).unwrap(), None, Some(&locals)).unwrap();
+                py.run(&CString::new(format!("assert x_py == {x}")).unwrap(), None, Some(&locals)).unwrap();
                 let roundtripped: NonZeroU128 = x_py.extract().unwrap();
                 assert_eq!(x, roundtripped);
             })
diff --git a/src/conversions/std/option.rs b/src/conversions/std/option.rs
index cd5edec7d6d..ae0ec441c61 100644
--- a/src/conversions/std/option.rs
+++ b/src/conversions/std/option.rs
@@ -1,6 +1,6 @@
 use crate::{
-    conversion::IntoPyObject, ffi, types::any::PyAnyMethods, AsPyPointer, Bound, BoundObject,
-    FromPyObject, PyAny, PyResult, Python,
+    conversion::IntoPyObject, types::any::PyAnyMethods, Bound, BoundObject, FromPyObject, PyAny,
+    PyResult, Python,
 };
 
 impl<'py, T> IntoPyObject<'py> for Option<T>
@@ -49,38 +49,3 @@ where
         }
     }
 }
-
-/// Convert `None` into a null pointer.
-unsafe impl<T> AsPyPointer for Option<T>
-where
-    T: AsPyPointer,
-{
-    #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.as_ref()
-            .map_or_else(std::ptr::null_mut, |t| t.as_ptr())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{PyObject, Python};
-
-    #[test]
-    fn test_option_as_ptr() {
-        Python::with_gil(|py| {
-            use crate::AsPyPointer;
-            let mut option: Option<PyObject> = None;
-            assert_eq!(option.as_ptr(), std::ptr::null_mut());
-
-            let none = py.None();
-            option = Some(none.clone_ref(py));
-
-            let ref_cnt = none.get_refcnt(py);
-            assert_eq!(option.as_ptr(), none.as_ptr());
-
-            // Ensure ref count not changed by as_ptr call
-            assert_eq!(none.get_refcnt(py), ref_cnt);
-        });
-    }
-}
diff --git a/src/conversions/std/time.rs b/src/conversions/std/time.rs
index 107ccf34cd8..53e3bf1a641 100644
--- a/src/conversions/std/time.rs
+++ b/src/conversions/std/time.rs
@@ -6,7 +6,7 @@ use crate::sync::GILOnceCell;
 use crate::types::any::PyAnyMethods;
 #[cfg(not(Py_LIMITED_API))]
 use crate::types::PyDeltaAccess;
-use crate::types::{timezone_utc, PyDateTime, PyDelta};
+use crate::types::{PyDateTime, PyDelta, PyTzInfo};
 use crate::{Borrowed, Bound, FromPyObject, Py, PyAny, PyErr, PyResult, Python};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
@@ -128,9 +128,8 @@ fn unix_epoch_py(py: Python<'_>) -> PyResult<Borrowed<'_, '_, PyDateTime>> {
     static UNIX_EPOCH: GILOnceCell<Py<PyDateTime>> = GILOnceCell::new();
     Ok(UNIX_EPOCH
         .get_or_try_init(py, || {
-            Ok::<_, PyErr>(
-                PyDateTime::new(py, 1970, 1, 1, 0, 0, 0, 0, Some(&timezone_utc(py)))?.into(),
-            )
+            let utc = PyTzInfo::utc(py)?;
+            Ok::<_, PyErr>(PyDateTime::new(py, 1970, 1, 1, 0, 0, 0, 0, Some(&utc))?.into())
         })?
         .bind_borrowed(py))
 }
@@ -138,7 +137,7 @@ fn unix_epoch_py(py: Python<'_>) -> PyResult<Borrowed<'_, '_, PyDateTime>> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::types::{timezone_utc, PyDict};
+    use crate::types::PyDict;
 
     #[test]
     fn test_duration_frompyobject() {
@@ -320,6 +319,7 @@ mod tests {
         second: u8,
         microsecond: u32,
     ) -> Bound<'_, PyDateTime> {
+        let utc = PyTzInfo::utc(py).unwrap();
         PyDateTime::new(
             py,
             year,
@@ -329,7 +329,7 @@ mod tests {
             minute,
             second,
             microsecond,
-            Some(&timezone_utc(py)),
+            Some(&utc),
         )
         .unwrap()
     }
@@ -337,7 +337,9 @@ mod tests {
     fn max_datetime(py: Python<'_>) -> Bound<'_, PyDateTime> {
         let naive_max = datetime_class(py).getattr("max").unwrap();
         let kargs = PyDict::new(py);
-        kargs.set_item("tzinfo", timezone_utc(py)).unwrap();
+        kargs
+            .set_item("tzinfo", PyTzInfo::utc(py).unwrap())
+            .unwrap();
         naive_max
             .call_method("replace", (), Some(&kargs))
             .unwrap()
diff --git a/src/conversions/time.rs b/src/conversions/time.rs
new file mode 100644
index 00000000000..f077b3be55d
--- /dev/null
+++ b/src/conversions/time.rs
@@ -0,0 +1,1504 @@
+#![cfg(feature = "time")]
+
+//! Conversions to and from [time](https://docs.rs/time/)’s `Date`,
+//! `Duration`, `OffsetDateTime`, `PrimitiveDateTime`, `Time`, `UtcDateTime` and `UtcOffset`.
+//!
+//! # Setup
+//!
+//! To use this feature, add this to your **`Cargo.toml`**:
+//!
+//! ```toml
+//! [dependencies]
+//! time = "0.3"
+#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"time\"] }")]
+//! ```
+//!
+//! Note that you must use compatible versions of time and PyO3.
+//! The required time version may vary based on the version of PyO3.
+//!
+//! ```rust
+//! use time::{Duration, OffsetDateTime, PrimitiveDateTime, Date, Time, Month};
+//! use pyo3::{Python, PyResult, IntoPyObject, types::PyAnyMethods};
+//!
+//! fn main() -> PyResult<()> {
+//!     pyo3::prepare_freethreaded_python();
+//!     Python::with_gil(|py| {
+//!         // Create a fixed date and time (2022-01-01 12:00:00 UTC)
+//!         let date = Date::from_calendar_date(2022, Month::January, 1).unwrap();
+//!         let time = Time::from_hms(12, 0, 0).unwrap();
+//!         let primitive_dt = PrimitiveDateTime::new(date, time);
+//!
+//!         // Convert to OffsetDateTime with UTC offset
+//!         let datetime = primitive_dt.assume_utc();
+//!
+//!         // Create a duration of 1 hour
+//!         let duration = Duration::hours(1);
+//!
+//!         // Convert to Python objects
+//!         let py_datetime = datetime.into_pyobject(py)?;
+//!         let py_timedelta = duration.into_pyobject(py)?;
+//!
+//!         // Add the duration to the datetime in Python
+//!         let py_result = py_datetime.add(py_timedelta)?;
+//!
+//!         // Convert the result back to Rust
+//!         let result: OffsetDateTime = py_result.extract()?;
+//!         assert_eq!(result.hour(), 13);
+//!
+//!         Ok(())
+//!     })
+//! }
+//! ```
+
+use crate::exceptions::{PyTypeError, PyValueError};
+#[cfg(Py_LIMITED_API)]
+use crate::intern;
+#[cfg(not(Py_LIMITED_API))]
+use crate::types::datetime::{PyDateAccess, PyDeltaAccess};
+use crate::types::{PyAnyMethods, PyDate, PyDateTime, PyDelta, PyNone, PyTime, PyTzInfo};
+#[cfg(not(Py_LIMITED_API))]
+use crate::types::{PyTimeAccess, PyTzInfoAccess};
+use crate::{Bound, FromPyObject, IntoPyObject, PyAny, PyErr, PyResult, Python};
+use time::{
+    Date, Duration, Month, OffsetDateTime, PrimitiveDateTime, Time, UtcDateTime, UtcOffset,
+};
+
+const SECONDS_PER_DAY: i64 = 86_400;
+
+// Macro for reference implementation
+macro_rules! impl_into_py_for_ref {
+    ($type:ty, $target:ty) => {
+        impl<'py> IntoPyObject<'py> for &$type {
+            type Target = $target;
+            type Output = Bound<'py, Self::Target>;
+            type Error = PyErr;
+
+            #[inline]
+            fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+                (*self).into_pyobject(py)
+            }
+        }
+    };
+}
+
+// Macro for month conversion
+macro_rules! month_from_number {
+    ($month:expr) => {
+        match $month {
+            1 => Month::January,
+            2 => Month::February,
+            3 => Month::March,
+            4 => Month::April,
+            5 => Month::May,
+            6 => Month::June,
+            7 => Month::July,
+            8 => Month::August,
+            9 => Month::September,
+            10 => Month::October,
+            11 => Month::November,
+            12 => Month::December,
+            _ => return Err(PyValueError::new_err("invalid month value")),
+        }
+    };
+}
+
+fn extract_date_time(dt: &Bound<'_, PyAny>) -> PyResult<(Date, Time)> {
+    #[cfg(not(Py_LIMITED_API))]
+    {
+        let dt = dt.downcast::<PyDateTime>()?;
+        let date = Date::from_calendar_date(
+            dt.get_year(),
+            month_from_number!(dt.get_month()),
+            dt.get_day(),
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range date"))?;
+
+        let time = Time::from_hms_micro(
+            dt.get_hour(),
+            dt.get_minute(),
+            dt.get_second(),
+            dt.get_microsecond(),
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range time"))?;
+        Ok((date, time))
+    }
+
+    #[cfg(Py_LIMITED_API)]
+    {
+        let date = Date::from_calendar_date(
+            dt.getattr(intern!(dt.py(), "year"))?.extract()?,
+            month_from_number!(dt.getattr(intern!(dt.py(), "month"))?.extract::<u8>()?),
+            dt.getattr(intern!(dt.py(), "day"))?.extract()?,
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range date"))?;
+
+        let time = Time::from_hms_micro(
+            dt.getattr(intern!(dt.py(), "hour"))?.extract()?,
+            dt.getattr(intern!(dt.py(), "minute"))?.extract()?,
+            dt.getattr(intern!(dt.py(), "second"))?.extract()?,
+            dt.getattr(intern!(dt.py(), "microsecond"))?.extract()?,
+        )
+        .map_err(|_| PyValueError::new_err("invalid or out-of-range time"))?;
+
+        Ok((date, time))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Duration {
+    type Target = PyDelta;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let total_seconds = self.whole_seconds();
+        let micro_seconds = self.subsec_microseconds();
+
+        // For negative durations, Python expects days to be negative and
+        // seconds/microseconds to be positive or zero
+        let (days, seconds) = if total_seconds < 0 && total_seconds % SECONDS_PER_DAY != 0 {
+            // For negative values, we need to round down (toward more negative)
+            // e.g., -10 seconds should be -1 days + 86390 seconds
+            let days = total_seconds.div_euclid(SECONDS_PER_DAY);
+            let seconds = total_seconds.rem_euclid(SECONDS_PER_DAY);
+            (days, seconds)
+        } else {
+            // For positive or exact negative days, use normal division
+            (
+                total_seconds / SECONDS_PER_DAY,
+                total_seconds % SECONDS_PER_DAY,
+            )
+        };
+        // Create the timedelta with days, seconds, microseconds
+        // Safe to unwrap as we've verified the values are within bounds
+        PyDelta::new(
+            py,
+            days.try_into().expect("days overflow"),
+            seconds.try_into().expect("seconds overflow"),
+            micro_seconds,
+            true,
+        )
+    }
+}
+
+impl FromPyObject<'_> for Duration {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Duration> {
+        #[cfg(not(Py_LIMITED_API))]
+        let (days, seconds, microseconds) = {
+            let delta = ob.downcast::<PyDelta>()?;
+            (
+                delta.get_days().into(),
+                delta.get_seconds().into(),
+                delta.get_microseconds().into(),
+            )
+        };
+
+        #[cfg(Py_LIMITED_API)]
+        let (days, seconds, microseconds) = {
+            (
+                ob.getattr(intern!(ob.py(), "days"))?.extract()?,
+                ob.getattr(intern!(ob.py(), "seconds"))?.extract()?,
+                ob.getattr(intern!(ob.py(), "microseconds"))?.extract()?,
+            )
+        };
+
+        Ok(
+            Duration::days(days)
+                + Duration::seconds(seconds)
+                + Duration::microseconds(microseconds),
+        )
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Date {
+    type Target = PyDate;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let year = self.year();
+        let month = self.month() as u8;
+        let day = self.day();
+
+        PyDate::new(py, year, month, day)
+    }
+}
+
+impl FromPyObject<'_> for Date {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Date> {
+        let (year, month, day) = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let date = ob.downcast::<PyDate>()?;
+                (date.get_year(), date.get_month(), date.get_day())
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            {
+                let year = ob.getattr(intern!(ob.py(), "year"))?.extract()?;
+                let month: u8 = ob.getattr(intern!(ob.py(), "month"))?.extract()?;
+                let day = ob.getattr(intern!(ob.py(), "day"))?.extract()?;
+                (year, month, day)
+            }
+        };
+
+        // Convert the month number to time::Month enum
+        let month = month_from_number!(month);
+
+        Date::from_calendar_date(year, month, day)
+            .map_err(|_| PyValueError::new_err("invalid or out-of-range date"))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for Time {
+    type Target = PyTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let hour = self.hour();
+        let minute = self.minute();
+        let second = self.second();
+        let microsecond = self.microsecond();
+
+        PyTime::new(py, hour, minute, second, microsecond, None)
+    }
+}
+
+impl FromPyObject<'_> for Time {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Time> {
+        let (hour, minute, second, microsecond) = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let time = ob.downcast::<PyTime>()?;
+                let hour: u8 = time.get_hour();
+                let minute: u8 = time.get_minute();
+                let second: u8 = time.get_second();
+                let microsecond = time.get_microsecond();
+                (hour, minute, second, microsecond)
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            {
+                let hour: u8 = ob.getattr(intern!(ob.py(), "hour"))?.extract()?;
+                let minute: u8 = ob.getattr(intern!(ob.py(), "minute"))?.extract()?;
+                let second: u8 = ob.getattr(intern!(ob.py(), "second"))?.extract()?;
+                let microsecond = ob.getattr(intern!(ob.py(), "microsecond"))?.extract()?;
+                (hour, minute, second, microsecond)
+            }
+        };
+
+        Time::from_hms_micro(hour, minute, second, microsecond)
+            .map_err(|_| PyValueError::new_err("invalid or out-of-range time"))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for PrimitiveDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let date = self.date();
+        let time = self.time();
+
+        let year = date.year();
+        let month = date.month() as u8;
+        let day = date.day();
+        let hour = time.hour();
+        let minute = time.minute();
+        let second = time.second();
+        let microsecond = time.microsecond();
+
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            None,
+        )
+    }
+}
+
+impl FromPyObject<'_> for PrimitiveDateTime {
+    fn extract_bound(dt: &Bound<'_, PyAny>) -> PyResult<PrimitiveDateTime> {
+        let has_tzinfo = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let dt = dt.downcast::<PyDateTime>()?;
+                dt.get_tzinfo().is_some()
+            }
+            #[cfg(Py_LIMITED_API)]
+            {
+                !dt.getattr(intern!(dt.py(), "tzinfo"))?.is_none()
+            }
+        };
+
+        if has_tzinfo {
+            return Err(PyTypeError::new_err("expected a datetime without tzinfo"));
+        }
+
+        let (date, time) = extract_date_time(dt)?;
+
+        Ok(PrimitiveDateTime::new(date, time))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for UtcOffset {
+    type Target = PyTzInfo;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        // Get offset in seconds
+        let seconds_offset = self.whole_seconds();
+        let td = PyDelta::new(py, 0, seconds_offset, 0, true)?;
+        PyTzInfo::fixed_offset(py, td)
+    }
+}
+
+impl FromPyObject<'_> for UtcOffset {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<UtcOffset> {
+        #[cfg(not(Py_LIMITED_API))]
+        let ob = ob.downcast::<PyTzInfo>()?;
+
+        // Get the offset in seconds from the Python tzinfo
+        let py_timedelta = ob.call_method1("utcoffset", (PyNone::get(ob.py()),))?;
+        if py_timedelta.is_none() {
+            return Err(PyTypeError::new_err(format!(
+                "{ob:?} is not a fixed offset timezone"
+            )));
+        }
+
+        let total_seconds: Duration = py_timedelta.extract()?;
+        let seconds = total_seconds.whole_seconds();
+
+        // Create the UtcOffset from the seconds
+        UtcOffset::from_whole_seconds(seconds as i32)
+            .map_err(|_| PyValueError::new_err("UTC offset out of bounds"))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for OffsetDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let date = self.date();
+        let time = self.time();
+        let offset = self.offset();
+
+        // Convert the offset to a Python tzinfo
+        let py_tzinfo = offset.into_pyobject(py)?;
+
+        let year = date.year();
+        let month = date.month() as u8;
+        let day = date.day();
+        let hour = time.hour();
+        let minute = time.minute();
+        let second = time.second();
+        let microsecond = time.microsecond();
+
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            Some(py_tzinfo.downcast()?),
+        )
+    }
+}
+
+impl FromPyObject<'_> for OffsetDateTime {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<OffsetDateTime> {
+        let offset: UtcOffset = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let dt = ob.downcast::<PyDateTime>()?;
+                let tzinfo = dt.get_tzinfo().ok_or_else(|| {
+                    PyTypeError::new_err("expected a datetime with non-None tzinfo")
+                })?;
+                tzinfo.extract()?
+            }
+            #[cfg(Py_LIMITED_API)]
+            {
+                let tzinfo = ob.getattr(intern!(ob.py(), "tzinfo"))?;
+                if tzinfo.is_none() {
+                    return Err(PyTypeError::new_err(
+                        "expected a datetime with non-None tzinfo",
+                    ));
+                }
+                tzinfo.extract()?
+            }
+        };
+
+        let (date, time) = extract_date_time(ob)?;
+
+        let primitive_dt = PrimitiveDateTime::new(date, time);
+        Ok(primitive_dt.assume_offset(offset))
+    }
+}
+
+impl<'py> IntoPyObject<'py> for UtcDateTime {
+    type Target = PyDateTime;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        let date = self.date();
+        let time = self.time();
+
+        let py_tzinfo = PyTzInfo::utc(py)?;
+
+        let year = date.year();
+        let month = date.month() as u8;
+        let day = date.day();
+        let hour = time.hour();
+        let minute = time.minute();
+        let second = time.second();
+        let microsecond = time.microsecond();
+
+        PyDateTime::new(
+            py,
+            year,
+            month,
+            day,
+            hour,
+            minute,
+            second,
+            microsecond,
+            Some(&py_tzinfo),
+        )
+    }
+}
+
+impl FromPyObject<'_> for UtcDateTime {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<UtcDateTime> {
+        let tzinfo = {
+            #[cfg(not(Py_LIMITED_API))]
+            {
+                let dt = ob.downcast::<PyDateTime>()?;
+                dt.get_tzinfo().ok_or_else(|| {
+                    PyTypeError::new_err("expected a datetime with non-None tzinfo")
+                })?
+            }
+
+            #[cfg(Py_LIMITED_API)]
+            {
+                let tzinfo = ob.getattr(intern!(ob.py(), "tzinfo"))?;
+                if tzinfo.is_none() {
+                    return Err(PyTypeError::new_err(
+                        "expected a datetime with non-None tzinfo",
+                    ));
+                }
+                tzinfo
+            }
+        };
+
+        // Verify that the tzinfo is UTC
+        let is_utc = tzinfo.eq(PyTzInfo::utc(ob.py())?)?;
+
+        if !is_utc {
+            return Err(PyValueError::new_err(
+                "expected a datetime with UTC timezone",
+            ));
+        }
+
+        let (date, time) = extract_date_time(ob)?;
+        let primitive_dt = PrimitiveDateTime::new(date, time);
+        Ok(primitive_dt.assume_utc().into())
+    }
+}
+
+impl_into_py_for_ref!(Duration, PyDelta);
+impl_into_py_for_ref!(Date, PyDate);
+impl_into_py_for_ref!(Time, PyTime);
+impl_into_py_for_ref!(PrimitiveDateTime, PyDateTime);
+impl_into_py_for_ref!(UtcOffset, PyTzInfo);
+impl_into_py_for_ref!(OffsetDateTime, PyDateTime);
+impl_into_py_for_ref!(UtcDateTime, PyDateTime);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::intern;
+    use crate::types::any::PyAnyMethods;
+    use crate::types::PyTypeMethods;
+
+    mod utils {
+        use super::*;
+
+        pub(crate) fn extract_py_delta_from_duration(
+            duration: Duration,
+            py: Python<'_>,
+        ) -> (i64, i64, i64) {
+            let py_delta = duration.into_pyobject(py).unwrap();
+            let days = py_delta
+                .getattr(intern!(py, "days"))
+                .unwrap()
+                .extract::<i64>()
+                .unwrap();
+            let seconds = py_delta
+                .getattr(intern!(py, "seconds"))
+                .unwrap()
+                .extract::<i64>()
+                .unwrap();
+            let microseconds = py_delta
+                .getattr(intern!(py, "microseconds"))
+                .unwrap()
+                .extract::<i64>()
+                .unwrap();
+            (days, seconds, microseconds)
+        }
+
+        pub(crate) fn extract_py_date_from_date(date: Date, py: Python<'_>) -> (i32, u8, u8) {
+            let py_date = date.into_pyobject(py).unwrap();
+
+            // Check the Python object is correct
+            let year = py_date
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<i32>()
+                .unwrap();
+            let month = py_date
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_date
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            (year, month, day)
+        }
+
+        pub(crate) fn create_date_from_py_date(
+            py: Python<'_>,
+            year: i32,
+            month: u8,
+            day: u8,
+        ) -> PyResult<Date> {
+            let datetime = py.import("datetime").unwrap();
+            let date_type = datetime.getattr(intern!(py, "date")).unwrap();
+            let py_date = date_type.call1((year, month, day));
+            match py_date {
+                Ok(py_date) => py_date.extract(),
+                Err(err) => Err(err),
+            }
+        }
+
+        pub(crate) fn create_time_from_py_time(
+            py: Python<'_>,
+            hour: u8,
+            minute: u8,
+            second: u8,
+            microseocnd: u32,
+        ) -> PyResult<Time> {
+            let datetime = py.import("datetime").unwrap();
+            let time_type = datetime.getattr(intern!(py, "time")).unwrap();
+            let py_time = time_type.call1((hour, minute, second, microseocnd));
+            match py_time {
+                Ok(py_time) => py_time.extract(),
+                Err(err) => Err(err),
+            }
+        }
+
+        pub(crate) fn extract_py_time_from_time(time: Time, py: Python<'_>) -> (u8, u8, u8, u32) {
+            let py_time = time.into_pyobject(py).unwrap();
+            let hour = py_time
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_time
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_time
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_time
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            (hour, minute, second, microsecond)
+        }
+
+        pub(crate) fn extract_date_time_from_primitive_date_time(
+            dt: PrimitiveDateTime,
+            py: Python<'_>,
+        ) -> (u32, u8, u8, u8, u8, u8, u32) {
+            let py_dt = dt.into_pyobject(py).unwrap();
+            let year = py_dt
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            let month = py_dt
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_dt
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let hour = py_dt
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_dt
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_dt
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_dt
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            (year, month, day, hour, minute, second, microsecond)
+        }
+
+        #[allow(clippy::too_many_arguments)]
+        pub(crate) fn create_primitive_date_time_from_py(
+            py: Python<'_>,
+            year: u32,
+            month: u8,
+            day: u8,
+            hour: u8,
+            minute: u8,
+            second: u8,
+            microsecond: u32,
+        ) -> PyResult<PrimitiveDateTime> {
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let py_dt = datetime_type.call1((year, month, day, hour, minute, second, microsecond));
+            match py_dt {
+                Ok(py_dt) => py_dt.extract(),
+                Err(err) => Err(err),
+            }
+        }
+
+        pub(crate) fn extract_total_seconds_from_utcoffset(
+            offset: UtcOffset,
+            py: Python<'_>,
+        ) -> f64 {
+            let py_tz = offset.into_pyobject(py).unwrap();
+            let utc_offset = py_tz.call_method1("utcoffset", (py.None(),)).unwrap();
+            let total_seconds = utc_offset
+                .getattr(intern!(py, "total_seconds"))
+                .unwrap()
+                .call0()
+                .unwrap()
+                .extract::<f64>()
+                .unwrap();
+            total_seconds
+        }
+
+        pub(crate) fn extract_from_utc_date_time(
+            dt: UtcDateTime,
+            py: Python<'_>,
+        ) -> (u32, u8, u8, u8, u8, u8, u32) {
+            let py_dt = dt.into_pyobject(py).unwrap();
+            let year = py_dt
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            let month = py_dt
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_dt
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let hour = py_dt
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_dt
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_dt
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_dt
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+            (year, month, day, hour, minute, second, microsecond)
+        }
+    }
+    #[test]
+    fn test_time_duration_conversion() {
+        Python::with_gil(|py| {
+            // Regular duration
+            let duration = Duration::new(1, 500_000_000); // 1.5 seconds
+            let (_, seconds, microseconds) = utils::extract_py_delta_from_duration(duration, py);
+            assert_eq!(seconds, 1);
+            assert_eq!(microseconds, 500_000);
+
+            // Check negative durations
+            let neg_duration = Duration::new(-10, 0); // -10 seconds
+            let (days, seconds, _) = utils::extract_py_delta_from_duration(neg_duration, py);
+            assert_eq!(days, -1);
+            assert_eq!(seconds, 86390); // 86400 - 10 seconds
+
+            // Test case for exact negative days (should use normal division path)
+            let exact_day = Duration::seconds(-86_400); // Exactly -1 day
+            let (days, seconds, microseconds) =
+                utils::extract_py_delta_from_duration(exact_day, py);
+            assert_eq!(days, -1);
+            assert_eq!(seconds, 0);
+            assert_eq!(microseconds, 0);
+        });
+    }
+
+    #[test]
+    fn test_time_duration_conversion_large_values() {
+        Python::with_gil(|py| {
+            // Large duration (close to max)
+            let large_duration = Duration::seconds(86_399_999_000_000); // Almost max
+            let (days, _, _) = utils::extract_py_delta_from_duration(large_duration, py);
+            assert!(days > 999_000_000);
+
+            // Test over limit (should yield Overflow error in python)
+            let too_large = Duration::seconds(86_400_000_000_000); // Over max
+            let result = too_large.into_pyobject(py);
+            assert!(result.is_err());
+            let err_type = result.unwrap_err().get_type(py).name().unwrap();
+            assert_eq!(err_type, "OverflowError");
+        });
+    }
+
+    #[test]
+    fn test_time_duration_nanosecond_resolution() {
+        Python::with_gil(|py| {
+            // Test nanosecond conversion to microseconds
+            let duration = Duration::new(0, 1_234_567);
+            let (_, _, microseconds) = utils::extract_py_delta_from_duration(duration, py);
+            // Python timedelta only has microsecond resolution, so we should get 1234 microseconds
+            assert_eq!(microseconds, 1234);
+        });
+    }
+
+    #[test]
+    fn test_time_duration_from_python() {
+        Python::with_gil(|py| {
+            // Create Python timedeltas with various values
+            let datetime = py.import("datetime").unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Test positive values
+            let py_delta1 = timedelta.call1((3, 7200, 500000)).unwrap();
+            let duration1: Duration = py_delta1.extract().unwrap();
+            assert_eq!(duration1.whole_days(), 3);
+            assert_eq!(duration1.whole_seconds() % 86400, 7200);
+            assert_eq!(duration1.subsec_nanoseconds(), 500000000);
+
+            // Test negative days
+            let py_delta2 = timedelta.call1((-2, 43200)).unwrap();
+            let duration2: Duration = py_delta2.extract().unwrap();
+            assert_eq!(duration2.whole_days(), -1);
+            assert_eq!(duration2.whole_seconds(), -129600);
+        });
+    }
+
+    #[test]
+    fn test_time_date_conversion() {
+        Python::with_gil(|py| {
+            // Regular date
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let (year, month, day) = utils::extract_py_date_from_date(date, py);
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+
+            // Test edge cases
+            let min_date = Date::from_calendar_date(1, Month::January, 1).unwrap();
+            let (min_year, min_month, min_day) = utils::extract_py_date_from_date(min_date, py);
+            assert_eq!(min_year, 1);
+            assert_eq!(min_month, 1);
+            assert_eq!(min_day, 1);
+
+            let max_date = Date::from_calendar_date(9999, Month::December, 31).unwrap();
+            let (max_year, max_month, max_day) = utils::extract_py_date_from_date(max_date, py);
+            assert_eq!(max_year, 9999);
+            assert_eq!(max_month, 12);
+            assert_eq!(max_day, 31);
+        });
+    }
+
+    #[test]
+    fn test_time_date_from_python() {
+        Python::with_gil(|py| {
+            let date1 = utils::create_date_from_py_date(py, 2023, 4, 15).unwrap();
+            assert_eq!(date1.year(), 2023);
+            assert_eq!(date1.month(), Month::April);
+            assert_eq!(date1.day(), 15);
+
+            // Test min date
+            let date2 = utils::create_date_from_py_date(py, 1, 1, 1).unwrap();
+            assert_eq!(date2.year(), 1);
+            assert_eq!(date2.month(), Month::January);
+            assert_eq!(date2.day(), 1);
+
+            // Test max date
+            let date3 = utils::create_date_from_py_date(py, 9999, 12, 31).unwrap();
+            assert_eq!(date3.year(), 9999);
+            assert_eq!(date3.month(), Month::December);
+            assert_eq!(date3.day(), 31);
+
+            // Test leap year date
+            let date4 = utils::create_date_from_py_date(py, 2024, 2, 29).unwrap();
+            assert_eq!(date4.year(), 2024);
+            assert_eq!(date4.month(), Month::February);
+            assert_eq!(date4.day(), 29);
+        });
+    }
+
+    #[test]
+    fn test_time_date_invalid_values() {
+        Python::with_gil(|py| {
+            let invalid_date = utils::create_date_from_py_date(py, 2023, 2, 30);
+            assert!(invalid_date.is_err());
+
+            // Test extraction of invalid month
+            let another_invalid_date = utils::create_date_from_py_date(py, 2023, 13, 1);
+            assert!(another_invalid_date.is_err());
+        });
+    }
+
+    #[test]
+    fn test_time_time_conversion() {
+        Python::with_gil(|py| {
+            // Regular time
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let (hour, minute, second, microsecond) = utils::extract_py_time_from_time(time, py);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+
+            // Test edge cases
+            let min_time = Time::from_hms_micro(0, 0, 0, 0).unwrap();
+            let (min_hour, min_minute, min_second, min_microsecond) =
+                utils::extract_py_time_from_time(min_time, py);
+            assert_eq!(min_hour, 0);
+            assert_eq!(min_minute, 0);
+            assert_eq!(min_second, 0);
+            assert_eq!(min_microsecond, 0);
+
+            let max_time = Time::from_hms_micro(23, 59, 59, 999999).unwrap();
+            let (max_hour, max_minute, max_second, max_microsecond) =
+                utils::extract_py_time_from_time(max_time, py);
+            assert_eq!(max_hour, 23);
+            assert_eq!(max_minute, 59);
+            assert_eq!(max_second, 59);
+            assert_eq!(max_microsecond, 999999);
+        });
+    }
+
+    #[test]
+    fn test_time_time_from_python() {
+        Python::with_gil(|py| {
+            let time1 = utils::create_time_from_py_time(py, 14, 30, 45, 123456).unwrap();
+            assert_eq!(time1.hour(), 14);
+            assert_eq!(time1.minute(), 30);
+            assert_eq!(time1.second(), 45);
+            assert_eq!(time1.microsecond(), 123456);
+
+            // Test min time
+            let time2 = utils::create_time_from_py_time(py, 0, 0, 0, 0).unwrap();
+            assert_eq!(time2.hour(), 0);
+            assert_eq!(time2.minute(), 0);
+            assert_eq!(time2.second(), 0);
+            assert_eq!(time2.microsecond(), 0);
+
+            // Test max time
+            let time3 = utils::create_time_from_py_time(py, 23, 59, 59, 999999).unwrap();
+            assert_eq!(time3.hour(), 23);
+            assert_eq!(time3.minute(), 59);
+            assert_eq!(time3.second(), 59);
+            assert_eq!(time3.microsecond(), 999999);
+        });
+    }
+
+    #[test]
+    fn test_time_time_invalid_values() {
+        Python::with_gil(|py| {
+            let result = utils::create_time_from_py_time(py, 24, 0, 0, 0);
+            assert!(result.is_err());
+            let result = utils::create_time_from_py_time(py, 12, 60, 0, 0);
+            assert!(result.is_err());
+            let result = utils::create_time_from_py_time(py, 12, 30, 60, 0);
+            assert!(result.is_err());
+            let result = utils::create_time_from_py_time(py, 12, 30, 30, 1000000);
+            assert!(result.is_err());
+        });
+    }
+
+    #[test]
+    fn test_time_time_with_timezone() {
+        Python::with_gil(|py| {
+            // Create Python time with timezone (just to ensure we can handle it properly)
+            let datetime = py.import("datetime").unwrap();
+            let time_type = datetime.getattr(intern!(py, "time")).unwrap();
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+
+            // Create time with timezone
+            let py_time_with_tz = time_type.call1((12, 30, 45, 0, tz_utc)).unwrap();
+            let time: Time = py_time_with_tz.extract().unwrap();
+
+            assert_eq!(time.hour(), 12);
+            assert_eq!(time.minute(), 30);
+            assert_eq!(time.second(), 45);
+        });
+    }
+
+    #[test]
+    fn test_time_primitive_datetime_conversion() {
+        Python::with_gil(|py| {
+            // Regular datetime
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let dt = PrimitiveDateTime::new(date, time);
+            let (year, month, day, hour, minute, second, microsecond) =
+                utils::extract_date_time_from_primitive_date_time(dt, py);
+
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+
+            // Test min datetime
+            let min_date = Date::from_calendar_date(1, Month::January, 1).unwrap();
+            let min_time = Time::from_hms_micro(0, 0, 0, 0).unwrap();
+            let min_dt = PrimitiveDateTime::new(min_date, min_time);
+            let (year, month, day, hour, minute, second, microsecond) =
+                utils::extract_date_time_from_primitive_date_time(min_dt, py);
+            assert_eq!(year, 1);
+            assert_eq!(month, 1);
+            assert_eq!(day, 1);
+            assert_eq!(hour, 0);
+            assert_eq!(minute, 0);
+            assert_eq!(second, 0);
+            assert_eq!(microsecond, 0);
+        });
+    }
+
+    #[test]
+    fn test_time_primitive_datetime_from_python() {
+        Python::with_gil(|py| {
+            let dt1 =
+                utils::create_primitive_date_time_from_py(py, 2023, 4, 15, 14, 30, 45, 123456)
+                    .unwrap();
+            assert_eq!(dt1.year(), 2023);
+            assert_eq!(dt1.month(), Month::April);
+            assert_eq!(dt1.day(), 15);
+            assert_eq!(dt1.hour(), 14);
+            assert_eq!(dt1.minute(), 30);
+            assert_eq!(dt1.second(), 45);
+            assert_eq!(dt1.microsecond(), 123456);
+
+            let dt2 = utils::create_primitive_date_time_from_py(py, 1, 1, 1, 0, 0, 0, 0).unwrap();
+            assert_eq!(dt2.year(), 1);
+            assert_eq!(dt2.month(), Month::January);
+            assert_eq!(dt2.day(), 1);
+            assert_eq!(dt2.hour(), 0);
+            assert_eq!(dt2.minute(), 0);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_offset_conversion() {
+        Python::with_gil(|py| {
+            // Test positive offset
+            let offset = UtcOffset::from_hms(5, 30, 0).unwrap();
+            let total_seconds = utils::extract_total_seconds_from_utcoffset(offset, py);
+            assert_eq!(total_seconds, 5.0 * 3600.0 + 30.0 * 60.0);
+
+            // Test negative offset
+            let neg_offset = UtcOffset::from_hms(-8, -15, 0).unwrap();
+            let neg_total_seconds = utils::extract_total_seconds_from_utcoffset(neg_offset, py);
+            assert_eq!(neg_total_seconds, -8.0 * 3600.0 - 15.0 * 60.0);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_offset_from_python() {
+        Python::with_gil(|py| {
+            // Create timezone objects
+            let datetime = py.import("datetime").unwrap();
+            let timezone = datetime.getattr(intern!(py, "timezone")).unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Test UTC
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+            let utc_offset: UtcOffset = tz_utc.extract().unwrap();
+            assert_eq!(utc_offset.whole_hours(), 0);
+            assert_eq!(utc_offset.minutes_past_hour(), 0);
+            assert_eq!(utc_offset.seconds_past_minute(), 0);
+
+            // Test positive offset
+            let td_pos = timedelta.call1((0, 19800, 0)).unwrap(); // 5 hours 30 minutes
+            let tz_pos = timezone.call1((td_pos,)).unwrap();
+            let offset_pos: UtcOffset = tz_pos.extract().unwrap();
+            assert_eq!(offset_pos.whole_hours(), 5);
+            assert_eq!(offset_pos.minutes_past_hour(), 30);
+
+            // Test negative offset
+            let td_neg = timedelta.call1((0, -30900, 0)).unwrap(); // -8 hours -35 minutes
+            let tz_neg = timezone.call1((td_neg,)).unwrap();
+            let offset_neg: UtcOffset = tz_neg.extract().unwrap();
+            assert_eq!(offset_neg.whole_hours(), -8);
+            assert_eq!(offset_neg.minutes_past_hour(), -35);
+        });
+    }
+
+    #[test]
+    fn test_time_offset_datetime_conversion() {
+        Python::with_gil(|py| {
+            // Create an OffsetDateTime with +5:30 offset
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let offset = UtcOffset::from_hms(5, 30, 0).unwrap();
+            let dt = PrimitiveDateTime::new(date, time).assume_offset(offset);
+
+            // Convert to Python
+            let py_dt = dt.into_pyobject(py).unwrap();
+
+            // Check components
+            let year = py_dt
+                .getattr(intern!(py, "year"))
+                .unwrap()
+                .extract::<i32>()
+                .unwrap();
+            let month = py_dt
+                .getattr(intern!(py, "month"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let day = py_dt
+                .getattr(intern!(py, "day"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let hour = py_dt
+                .getattr(intern!(py, "hour"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let minute = py_dt
+                .getattr(intern!(py, "minute"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let second = py_dt
+                .getattr(intern!(py, "second"))
+                .unwrap()
+                .extract::<u8>()
+                .unwrap();
+            let microsecond = py_dt
+                .getattr(intern!(py, "microsecond"))
+                .unwrap()
+                .extract::<u32>()
+                .unwrap();
+
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+
+            // Check timezone offset
+            let tzinfo = py_dt.getattr(intern!(py, "tzinfo")).unwrap();
+            let utcoffset = tzinfo.call_method1("utcoffset", (py_dt,)).unwrap();
+            let seconds = utcoffset
+                .call_method0("total_seconds")
+                .unwrap()
+                .extract::<f64>()
+                .unwrap();
+            assert_eq!(seconds, 5.0 * 3600.0 + 30.0 * 60.0);
+        });
+    }
+
+    #[test]
+    fn test_time_offset_datetime_from_python() {
+        Python::with_gil(|py| {
+            // Create Python datetime with timezone
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let timezone = datetime.getattr(intern!(py, "timezone")).unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Create a timezone (+5:30)
+            let td = timedelta.call1((0, 19800, 0)).unwrap(); // 5:30:00
+            let tz = timezone.call1((td,)).unwrap();
+
+            // Create datetime with this timezone
+            let py_dt = datetime_type
+                .call1((2023, 4, 15, 14, 30, 45, 123456, tz))
+                .unwrap();
+
+            // Extract to Rust
+            let dt: OffsetDateTime = py_dt.extract().unwrap();
+
+            // Verify components
+            assert_eq!(dt.year(), 2023);
+            assert_eq!(dt.month(), Month::April);
+            assert_eq!(dt.day(), 15);
+            assert_eq!(dt.hour(), 14);
+            assert_eq!(dt.minute(), 30);
+            assert_eq!(dt.second(), 45);
+            assert_eq!(dt.microsecond(), 123456);
+            assert_eq!(dt.offset().whole_hours(), 5);
+            assert_eq!(dt.offset().minutes_past_hour(), 30);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_datetime_conversion() {
+        Python::with_gil(|py| {
+            let date = Date::from_calendar_date(2023, Month::April, 15).unwrap();
+            let time = Time::from_hms_micro(14, 30, 45, 123456).unwrap();
+            let primitive_dt = PrimitiveDateTime::new(date, time);
+            let dt: UtcDateTime = primitive_dt.assume_utc().into();
+            let (year, month, day, hour, minute, second, microsecond) =
+                utils::extract_from_utc_date_time(dt, py);
+
+            assert_eq!(year, 2023);
+            assert_eq!(month, 4);
+            assert_eq!(day, 15);
+            assert_eq!(hour, 14);
+            assert_eq!(minute, 30);
+            assert_eq!(second, 45);
+            assert_eq!(microsecond, 123456);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_datetime_from_python() {
+        Python::with_gil(|py| {
+            // Create Python UTC datetime
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let tz_utc = PyTzInfo::utc(py).unwrap();
+
+            // Create datetime with UTC timezone
+            let py_dt = datetime_type
+                .call1((2023, 4, 15, 14, 30, 45, 123456, tz_utc))
+                .unwrap();
+
+            // Convert to Rust
+            let dt: UtcDateTime = py_dt.extract().unwrap();
+
+            // Verify components
+            assert_eq!(dt.year(), 2023);
+            assert_eq!(dt.month(), Month::April);
+            assert_eq!(dt.day(), 15);
+            assert_eq!(dt.hour(), 14);
+            assert_eq!(dt.minute(), 30);
+            assert_eq!(dt.second(), 45);
+            assert_eq!(dt.microsecond(), 123456);
+        });
+    }
+
+    #[test]
+    fn test_time_utc_datetime_non_utc_timezone() {
+        Python::with_gil(|py| {
+            // Create Python datetime with non-UTC timezone
+            let datetime = py.import("datetime").unwrap();
+            let datetime_type = datetime.getattr(intern!(py, "datetime")).unwrap();
+            let timezone = datetime.getattr(intern!(py, "timezone")).unwrap();
+            let timedelta = datetime.getattr(intern!(py, "timedelta")).unwrap();
+
+            // Create a non-UTC timezone (EST = UTC-5)
+            let td = timedelta.call1((0, -18000, 0)).unwrap(); // -5 hours
+            let tz_est = timezone.call1((td,)).unwrap();
+
+            // Create datetime with EST timezone
+            let py_dt = datetime_type
+                .call1((2023, 4, 15, 14, 30, 45, 123456, tz_est))
+                .unwrap();
+
+            // Try to convert to UtcDateTime - should fail
+            let result: Result<UtcDateTime, _> = py_dt.extract();
+            assert!(result.is_err());
+        });
+    }
+
+    #[cfg(not(any(target_arch = "wasm32", Py_GIL_DISABLED)))]
+    mod proptests {
+        use super::*;
+        use proptest::proptest;
+
+        proptest! {
+            #[test]
+            fn test_time_duration_roundtrip(days in -9999i64..=9999i64, seconds in -86399i64..=86399i64, microseconds in -999999i64..=999999i64) {
+                // Generate a valid duration that should roundtrip successfully
+                Python::with_gil(|py| {
+                    let duration = Duration::days(days) + Duration::seconds(seconds) + Duration::microseconds(microseconds);
+
+                    // Skip if outside Python's timedelta bounds
+                    let max_seconds = 86_399_999_913_600;
+                    if duration.whole_seconds() <= max_seconds && duration.whole_seconds() >= -max_seconds {
+                        let py_delta = duration.into_pyobject(py).unwrap();
+
+                        // You could add FromPyObject for Duration to fully test the roundtrip
+                        // For now we'll just check that the Python object has the expected properties
+                        let total_seconds = py_delta.call_method0(intern!(py, "total_seconds")).unwrap().extract::<f64>().unwrap();
+                        let expected_seconds = duration.whole_seconds() as f64 + (duration.subsec_nanoseconds() as f64 / 1_000_000_000.0);
+
+                        // Allow small floating point differences
+                        assert_eq!(total_seconds, expected_seconds);
+                    }
+                })
+            }
+
+            #[test]
+            fn test_all_valid_dates(
+                year in 1i32..=9999,
+                month_num in 1u8..=12,
+            ) {
+                Python::with_gil(|py| {
+                    let month = match month_num {
+                        1 => (Month::January, 31),
+                        2 => {
+                            // Handle leap years
+                            if (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) {
+                                (Month::February, 29)
+                            } else {
+                                (Month::February, 28)
+                            }
+                        },
+                        3 => (Month::March, 31),
+                        4 => (Month::April, 30),
+                        5 => (Month::May, 31),
+                        6 => (Month::June, 30),
+                        7 => (Month::July, 31),
+                        8 => (Month::August, 31),
+                        9 => (Month::September, 30),
+                        10 => (Month::October, 31),
+                        11 => (Month::November, 30),
+                        12 => (Month::December, 31),
+                        _ => unreachable!(),
+                    };
+
+                    // Test the entire month
+                    for day in 1..=month.1 {
+                        let date = Date::from_calendar_date(year, month.0, day).unwrap();
+                        let py_date = date.into_pyobject(py).unwrap();
+                        let roundtripped: Date = py_date.extract().unwrap();
+                        assert_eq!(date, roundtripped);
+                    }
+                });
+            }
+
+            #[test]
+            fn test_time_time_roundtrip_random(
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32
+            ) {
+                Python::with_gil(|py| {
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+                    let py_time = time.into_pyobject(py).unwrap();
+                    let roundtripped: Time = py_time.extract().unwrap();
+                    assert_eq!(time, roundtripped);
+                });
+            }
+
+            #[test]
+            fn test_time_primitive_datetime_roundtrip_random(
+                year in 1i32..=9999i32,
+                month in 1u8..=12u8,
+                day in 1u8..=28u8, // Use only valid days for all months
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32
+            ) {
+                Python::with_gil(|py| {
+                    let month = match month {
+                        1 => Month::January,
+                        2 => Month::February,
+                        3 => Month::March,
+                        4 => Month::April,
+                        5 => Month::May,
+                        6 => Month::June,
+                        7 => Month::July,
+                        8 => Month::August,
+                        9 => Month::September,
+                        10 => Month::October,
+                        11 => Month::November,
+                        12 => Month::December,
+                        _ => unreachable!(),
+                    };
+
+                    let date = Date::from_calendar_date(year, month, day).unwrap();
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+                    let dt = PrimitiveDateTime::new(date, time);
+
+                    let py_dt = dt.into_pyobject(py).unwrap();
+                    let roundtripped: PrimitiveDateTime = py_dt.extract().unwrap();
+                    assert_eq!(dt, roundtripped);
+                });
+            }
+
+            #[test]
+            fn test_time_utc_offset_roundtrip_random(
+                hours in -23i8..=23i8,
+                minutes in -59i8..=59i8
+            ) {
+                // Skip invalid combinations where hour and minute signs don't match
+                if (hours < 0 && minutes > 0) || (hours > 0 && minutes < 0) {
+                    return Ok(());
+                }
+
+                Python::with_gil(|py| {
+                    if let Ok(offset) = UtcOffset::from_hms(hours, minutes, 0) {
+                        let py_tz = offset.into_pyobject(py).unwrap();
+                        let roundtripped: UtcOffset = py_tz.extract().unwrap();
+                        assert_eq!(roundtripped.whole_hours(), hours);
+                        assert_eq!(roundtripped.minutes_past_hour(), minutes);
+                    }
+                });
+            }
+
+            #[test]
+            fn test_time_offset_datetime_roundtrip_random(
+                year in 1i32..=9999i32,
+                month in 1u8..=12u8,
+                day in 1u8..=28u8, // Use only valid days for all months
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32,
+                tz_hour in -23i8..=23i8,
+                tz_minute in 0i8..=59i8
+            ) {
+                Python::with_gil(|py| {
+                    let month = match month {
+                        1 => Month::January,
+                        2 => Month::February,
+                        3 => Month::March,
+                        4 => Month::April,
+                        5 => Month::May,
+                        6 => Month::June,
+                        7 => Month::July,
+                        8 => Month::August,
+                        9 => Month::September,
+                        10 => Month::October,
+                        11 => Month::November,
+                        12 => Month::December,
+                        _ => unreachable!(),
+                    };
+
+                    let date = Date::from_calendar_date(year, month, day).unwrap();
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+
+                    // Handle timezone sign correctly
+                    let tz_minute = if tz_hour < 0 { -tz_minute } else { tz_minute };
+
+                    if let Ok(offset) = UtcOffset::from_hms(tz_hour, tz_minute, 0) {
+                        let dt = PrimitiveDateTime::new(date, time).assume_offset(offset);
+                        let py_dt = dt.into_pyobject(py).unwrap();
+                        let roundtripped: OffsetDateTime = py_dt.extract().unwrap();
+
+                        assert_eq!(dt.year(), roundtripped.year());
+                        assert_eq!(dt.month(), roundtripped.month());
+                        assert_eq!(dt.day(), roundtripped.day());
+                        assert_eq!(dt.hour(), roundtripped.hour());
+                        assert_eq!(dt.minute(), roundtripped.minute());
+                        assert_eq!(dt.second(), roundtripped.second());
+                        assert_eq!(dt.microsecond(), roundtripped.microsecond());
+                        assert_eq!(dt.offset().whole_hours(), roundtripped.offset().whole_hours());
+                        assert_eq!(dt.offset().minutes_past_hour(), roundtripped.offset().minutes_past_hour());
+                    }
+                });
+            }
+
+            #[test]
+            fn test_time_utc_datetime_roundtrip_random(
+                year in 1i32..=9999i32,
+                month in 1u8..=12u8,
+                day in 1u8..=28u8, // Use only valid days for all months
+                hour in 0u8..=23u8,
+                minute in 0u8..=59u8,
+                second in 0u8..=59u8,
+                microsecond in 0u32..=999999u32
+            ) {
+                Python::with_gil(|py| {
+                    let month = match month {
+                        1 => Month::January,
+                        2 => Month::February,
+                        3 => Month::March,
+                        4 => Month::April,
+                        5 => Month::May,
+                        6 => Month::June,
+                        7 => Month::July,
+                        8 => Month::August,
+                        9 => Month::September,
+                        10 => Month::October,
+                        11 => Month::November,
+                        12 => Month::December,
+                        _ => unreachable!(),
+                    };
+
+                    let date = Date::from_calendar_date(year, month, day).unwrap();
+                    let time = Time::from_hms_micro(hour, minute, second, microsecond).unwrap();
+                    let primitive_dt = PrimitiveDateTime::new(date, time);
+                    let dt: UtcDateTime = primitive_dt.assume_utc().into();
+
+                    let py_dt = dt.into_pyobject(py).unwrap();
+                    let roundtripped: UtcDateTime = py_dt.extract().unwrap();
+
+                    assert_eq!(dt.year(), roundtripped.year());
+                    assert_eq!(dt.month(), roundtripped.month());
+                    assert_eq!(dt.day(), roundtripped.day());
+                    assert_eq!(dt.hour(), roundtripped.hour());
+                    assert_eq!(dt.minute(), roundtripped.minute());
+                    assert_eq!(dt.second(), roundtripped.second());
+                    assert_eq!(dt.microsecond(), roundtripped.microsecond());
+                })
+            }
+        }
+    }
+}
diff --git a/src/coroutine/waker.rs b/src/coroutine/waker.rs
index 1600f56d9c6..e88ed71150f 100644
--- a/src/coroutine/waker.rs
+++ b/src/coroutine/waker.rs
@@ -41,10 +41,10 @@ impl Wake for AsyncioWaker {
     }
 
     fn wake_by_ref(self: &Arc<Self>) {
-        Python::with_gil(|gil| {
-            if let Some(loop_and_future) = self.0.get_or_init(gil, || None) {
+        Python::with_gil(|py| {
+            if let Some(loop_and_future) = self.0.get_or_init(py, || None) {
                 loop_and_future
-                    .set_result(gil)
+                    .set_result(py)
                     .expect("unexpected error in coroutine waker");
             }
         });
diff --git a/src/err/impls.rs b/src/err/impls.rs
index 1af45b7e628..814544a86f4 100644
--- a/src/err/impls.rs
+++ b/src/err/impls.rs
@@ -155,7 +155,7 @@ mod tests {
                 let rust_err = io::Error::new(kind, "some error msg");
 
                 let py_err: PyErr = rust_err.into();
-                let py_err_msg = format!("{}: some error msg", expected_ty);
+                let py_err_msg = format!("{expected_ty}: some error msg");
                 assert_eq!(py_err.to_string(), py_err_msg);
                 let py_error_clone = py_err.clone_ref(py);
 
diff --git a/src/err/mod.rs b/src/err/mod.rs
index 74b07d5c17a..c4d5379cff6 100644
--- a/src/err/mod.rs
+++ b/src/err/mod.rs
@@ -671,7 +671,7 @@ impl std::fmt::Debug for PyErr {
                             // error, but we can't guarantee that the error
                             // won't have another unformattable traceback inside
                             // it and we want to avoid an infinite recursion.
-                            format!("<unformattable {:?}>", tb)
+                            format!("<unformattable {tb:?}>")
                         }
                     }),
                 )
@@ -685,7 +685,7 @@ impl std::fmt::Display for PyErr {
         Python::with_gil(|py| {
             let value = self.value(py);
             let type_name = value.get_type().qualname().map_err(|_| std::fmt::Error)?;
-            write!(f, "{}", type_name)?;
+            write!(f, "{type_name}")?;
             if let Ok(s) = value.str() {
                 write!(f, ": {}", &s.to_string_lossy())
             } else {
@@ -946,7 +946,7 @@ mod tests {
                 .run(ffi::c_str!("raise Exception('banana')"), None, None)
                 .expect_err("raising should have given us an error");
 
-            let debug_str = format!("{:?}", err);
+            let debug_str = format!("{err:?}");
             assert!(debug_str.starts_with("PyErr { "));
             assert!(debug_str.ends_with(" }"));
 
diff --git a/src/exceptions.rs b/src/exceptions.rs
index dbbc8c714f1..5f39d474a72 100644
--- a/src/exceptions.rs
+++ b/src/exceptions.rs
@@ -996,7 +996,7 @@ mod tests {
                 .into_value(py)
                 .into_bound(py);
             assert_eq!(
-                format!("{:?}", exc),
+                format!("{exc:?}"),
                 exc.repr().unwrap().extract::<String>().unwrap()
             );
         });
@@ -1025,7 +1025,7 @@ mod tests {
         Python::with_gil(|py| {
             let decode_err = PyUnicodeDecodeError::new_utf8(py, invalid_utf8, err).unwrap();
             assert_eq!(
-                format!("{:?}", decode_err),
+                format!("{decode_err:?}"),
                 "UnicodeDecodeError('utf-8', b'fo\\xd8o', 2, 3, 'invalid utf-8')"
             );
 
diff --git a/src/ffi/tests.rs b/src/ffi/tests.rs
index b2d9e4d39cd..7de4e3b1875 100644
--- a/src/ffi/tests.rs
+++ b/src/ffi/tests.rs
@@ -2,12 +2,12 @@ use crate::ffi::{self, *};
 use crate::types::any::PyAnyMethods;
 use crate::Python;
 
-#[cfg(all(not(Py_LIMITED_API), any(not(PyPy), feature = "macros")))]
+#[cfg(all(not(Py_LIMITED_API), any(not(any(PyPy, GraalPy)), feature = "macros")))]
 use crate::types::PyString;
 
 #[cfg(not(Py_LIMITED_API))]
 use crate::{types::PyDict, Bound, PyAny};
-#[cfg(not(any(Py_3_12, Py_LIMITED_API)))]
+#[cfg(not(any(Py_3_12, Py_LIMITED_API, GraalPy)))]
 use libc::wchar_t;
 
 #[cfg(not(Py_LIMITED_API))]
@@ -114,10 +114,11 @@ fn test_timezone_from_offset_and_name() {
 }
 
 #[test]
-#[cfg(not(Py_LIMITED_API))]
+#[cfg(not(any(Py_LIMITED_API, GraalPy)))]
 fn ascii_object_bitfield() {
     let ob_base: PyObject = unsafe { std::mem::zeroed() };
 
+    #[cfg_attr(Py_3_14, allow(unused_mut, unused_variables))]
     let mut o = PyASCIIObject {
         ob_base,
         length: 0,
@@ -128,6 +129,7 @@ fn ascii_object_bitfield() {
         wstr: std::ptr::null_mut() as *mut wchar_t,
     };
 
+    #[cfg(not(Py_3_14))]
     unsafe {
         assert_eq!(o.interned(), 0);
         assert_eq!(o.kind(), 0);
@@ -158,11 +160,16 @@ fn ascii_object_bitfield() {
         o.set_ready(1);
         #[cfg(not(Py_3_12))]
         assert_eq!(o.ready(), 1);
+
+        #[cfg(Py_3_12)]
+        o.set_statically_allocated(1);
+        #[cfg(Py_3_12)]
+        assert_eq!(o.statically_allocated(), 1);
     }
 }
 
 #[test]
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 fn ascii() {
     Python::with_gil(|py| {
         // This test relies on implementation details of PyString.
@@ -170,24 +177,28 @@ fn ascii() {
         let ptr = s.as_ptr();
 
         unsafe {
-            let ascii_ptr = ptr as *mut PyASCIIObject;
-            let ascii = ascii_ptr.as_ref().unwrap();
-
-            assert_eq!(ascii.interned(), 0);
-            assert_eq!(ascii.kind(), PyUnicode_1BYTE_KIND);
-            assert_eq!(ascii.compact(), 1);
-            assert_eq!(ascii.ascii(), 1);
-            #[cfg(not(Py_3_12))]
-            assert_eq!(ascii.ready(), 1);
-
-            assert_eq!(PyUnicode_IS_ASCII(ptr), 1);
-            assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
-            assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 1);
+            #[cfg(not(Py_3_14))]
+            {
+                let ascii_ptr = ptr as *mut PyASCIIObject;
+                let ascii = ascii_ptr.as_ref().unwrap();
+
+                assert_eq!(ascii.interned(), 0);
+                assert_eq!(ascii.kind(), PyUnicode_1BYTE_KIND);
+                assert_eq!(ascii.compact(), 1);
+                assert_eq!(ascii.ascii(), 1);
+                #[cfg(not(Py_3_12))]
+                assert_eq!(ascii.ready(), 1);
+
+                assert_eq!(PyUnicode_IS_ASCII(ptr), 1);
+                assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
+                assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 1);
+            }
 
             assert!(!PyUnicode_1BYTE_DATA(ptr).is_null());
             // 2 and 4 byte macros return nonsense for this string instance.
             assert_eq!(PyUnicode_KIND(ptr), PyUnicode_1BYTE_KIND);
 
+            #[cfg(not(Py_3_14))]
             assert!(!_PyUnicode_COMPACT_DATA(ptr).is_null());
             // _PyUnicode_NONCOMPACT_DATA isn't valid for compact strings.
             assert!(!PyUnicode_DATA(ptr).is_null());
@@ -203,7 +214,7 @@ fn ascii() {
 }
 
 #[test]
-#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+#[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
 fn ucs4() {
     Python::with_gil(|py| {
         let s = "哈哈🐈";
@@ -211,23 +222,26 @@ fn ucs4() {
         let ptr = py_string.as_ptr();
 
         unsafe {
-            let ascii_ptr = ptr as *mut PyASCIIObject;
-            let ascii = ascii_ptr.as_ref().unwrap();
-
-            assert_eq!(ascii.interned(), 0);
-            assert_eq!(ascii.kind(), PyUnicode_4BYTE_KIND);
-            assert_eq!(ascii.compact(), 1);
-            assert_eq!(ascii.ascii(), 0);
-            #[cfg(not(Py_3_12))]
-            assert_eq!(ascii.ready(), 1);
-
-            assert_eq!(PyUnicode_IS_ASCII(ptr), 0);
-            assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
-            assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 0);
-
+            #[cfg(not(Py_3_14))]
+            {
+                let ascii_ptr = ptr as *mut PyASCIIObject;
+                let ascii = ascii_ptr.as_ref().unwrap();
+
+                assert_eq!(ascii.interned(), 0);
+                assert_eq!(ascii.kind(), PyUnicode_4BYTE_KIND);
+                assert_eq!(ascii.compact(), 1);
+                assert_eq!(ascii.ascii(), 0);
+                #[cfg(not(Py_3_12))]
+                assert_eq!(ascii.ready(), 1);
+
+                assert_eq!(PyUnicode_IS_ASCII(ptr), 0);
+                assert_eq!(PyUnicode_IS_COMPACT(ptr), 1);
+                assert_eq!(PyUnicode_IS_COMPACT_ASCII(ptr), 0);
+            }
             assert!(!PyUnicode_4BYTE_DATA(ptr).is_null());
             assert_eq!(PyUnicode_KIND(ptr), PyUnicode_4BYTE_KIND);
 
+            #[cfg(not(Py_3_14))]
             assert!(!_PyUnicode_COMPACT_DATA(ptr).is_null());
             // _PyUnicode_NONCOMPACT_DATA isn't valid for compact strings.
             assert!(!PyUnicode_DATA(ptr).is_null());
@@ -248,14 +262,14 @@ fn ucs4() {
 #[test]
 #[cfg(not(Py_LIMITED_API))]
 #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
-#[cfg(not(PyPy))]
+#[cfg(not(all(PyPy, not(Py_3_10))))]
 fn test_get_tzinfo() {
-    use crate::types::timezone_utc;
+    use crate::types::PyTzInfo;
 
     crate::Python::with_gil(|py| {
         use crate::types::{PyDateTime, PyTime};
 
-        let utc = &timezone_utc(py);
+        let utc: &Bound<'_, _> = &PyTzInfo::utc(py).unwrap();
 
         let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(utc)).unwrap();
 
diff --git a/src/gil.rs b/src/gil.rs
index 5fccb04ef6a..a8a170a0bba 100644
--- a/src/gil.rs
+++ b/src/gil.rs
@@ -161,33 +161,34 @@ impl GILGuard {
         //    extension-module feature is not activated - extension modules don't care about
         //    auto-initialize so this avoids breaking existing builds.
         //  - Otherwise, just check the GIL is initialized.
-        cfg_if::cfg_if! {
-            if #[cfg(all(feature = "auto-initialize", not(any(PyPy, GraalPy))))] {
+        #[cfg(all(feature = "auto-initialize", not(any(PyPy, GraalPy))))]
+        {
+            prepare_freethreaded_python();
+        }
+        #[cfg(not(all(feature = "auto-initialize", not(any(PyPy, GraalPy)))))]
+        {
+            // This is a "hack" to make running `cargo test` for PyO3 convenient (i.e. no need
+            // to specify `--features auto-initialize` manually. Tests within the crate itself
+            // all depend on the auto-initialize feature for conciseness but Cargo does not
+            // provide a mechanism to specify required features for tests.
+            #[cfg(not(any(PyPy, GraalPy)))]
+            if option_env!("CARGO_PRIMARY_PACKAGE").is_some() {
                 prepare_freethreaded_python();
-            } else {
-                // This is a "hack" to make running `cargo test` for PyO3 convenient (i.e. no need
-                // to specify `--features auto-initialize` manually. Tests within the crate itself
-                // all depend on the auto-initialize feature for conciseness but Cargo does not
-                // provide a mechanism to specify required features for tests.
-                #[cfg(not(any(PyPy, GraalPy)))]
-                if option_env!("CARGO_PRIMARY_PACKAGE").is_some() {
-                    prepare_freethreaded_python();
-                }
-
-                START.call_once_force(|_| unsafe {
-                    // Use call_once_force because if there is a panic because the interpreter is
-                    // not initialized, it's fine for the user to initialize the interpreter and
-                    // retry.
-                    assert_ne!(
-                        ffi::Py_IsInitialized(),
-                        0,
-                        "The Python interpreter is not initialized and the `auto-initialize` \
+            }
+
+            START.call_once_force(|_| unsafe {
+                // Use call_once_force because if there is a panic because the interpreter is
+                // not initialized, it's fine for the user to initialize the interpreter and
+                // retry.
+                assert_ne!(
+                    ffi::Py_IsInitialized(),
+                    0,
+                    "The Python interpreter is not initialized and the `auto-initialize` \
                          feature is not enabled.\n\n\
                          Consider calling `pyo3::prepare_freethreaded_python()` before attempting \
                          to use Python APIs."
-                    );
-                });
-            }
+                );
+            });
         }
 
         // SAFETY: We have ensured the Python interpreter is initialized.
diff --git a/src/impl_/coroutine.rs b/src/impl_/coroutine.rs
index f893a2c2fe9..1d065c2f346 100644
--- a/src/impl_/coroutine.rs
+++ b/src/impl_/coroutine.rs
@@ -50,9 +50,9 @@ impl<T: PyClass> Deref for RefGuard<T> {
 
 impl<T: PyClass> Drop for RefGuard<T> {
     fn drop(&mut self) {
-        Python::with_gil(|gil| {
+        Python::with_gil(|py| {
             self.0
-                .bind(gil)
+                .bind(py)
                 .get_class_object()
                 .borrow_checker()
                 .release_borrow()
@@ -87,9 +87,9 @@ impl<T: PyClass<Frozen = False>> DerefMut for RefMutGuard<T> {
 
 impl<T: PyClass<Frozen = False>> Drop for RefMutGuard<T> {
     fn drop(&mut self) {
-        Python::with_gil(|gil| {
+        Python::with_gil(|py| {
             self.0
-                .bind(gil)
+                .bind(py)
                 .get_class_object()
                 .borrow_checker()
                 .release_borrow_mut()
diff --git a/src/impl_/extract_argument.rs b/src/impl_/extract_argument.rs
index 025f050c8a9..7107c51b26a 100644
--- a/src/impl_/extract_argument.rs
+++ b/src/impl_/extract_argument.rs
@@ -200,7 +200,7 @@ pub fn from_py_with_with_default<'a, 'py, T>(
 #[doc(hidden)]
 #[cold]
 pub fn argument_extraction_error(py: Python<'_>, arg_name: &str, error: PyErr) -> PyErr {
-    if error.get_type(py).is(&py.get_type::<PyTypeError>()) {
+    if error.get_type(py).is(py.get_type::<PyTypeError>()) {
         let remapped_error =
             PyTypeError::new_err(format!("argument '{}': {}", arg_name, error.value(py)));
         remapped_error.set_cause(py, error.cause(py));
diff --git a/src/impl_/frompyobject.rs b/src/impl_/frompyobject.rs
index 9f3f77340bc..729509c2231 100644
--- a/src/impl_/frompyobject.rs
+++ b/src/impl_/frompyobject.rs
@@ -36,7 +36,7 @@ fn extract_traceback(py: Python<'_>, mut error: PyErr) -> String {
 
     let mut error_msg = error.to_string();
     while let Some(cause) = error.cause(py) {
-        write!(&mut error_msg, ", caused by {}", cause).unwrap();
+        write!(&mut error_msg, ", caused by {cause}").unwrap();
         error = cause
     }
     error_msg
@@ -86,8 +86,7 @@ fn failed_to_extract_struct_field(
     field_name: &str,
 ) -> PyErr {
     let new_err = PyTypeError::new_err(format!(
-        "failed to extract field {}.{}",
-        struct_name, field_name
+        "failed to extract field {struct_name}.{field_name}"
     ));
     new_err.set_cause(py, ::std::option::Option::Some(inner_err));
     new_err
@@ -136,8 +135,7 @@ fn failed_to_extract_tuple_struct_field(
     struct_name: &str,
     index: usize,
 ) -> PyErr {
-    let new_err =
-        PyTypeError::new_err(format!("failed to extract field {}.{}", struct_name, index));
+    let new_err = PyTypeError::new_err(format!("failed to extract field {struct_name}.{index}"));
     new_err.set_cause(py, ::std::option::Option::Some(inner_err));
     new_err
 }
diff --git a/src/impl_/pyclass.rs b/src/impl_/pyclass.rs
index c646b35ecfe..3191b8b902b 100644
--- a/src/impl_/pyclass.rs
+++ b/src/impl_/pyclass.rs
@@ -176,6 +176,9 @@ pub trait PyClassImpl: Sized + 'static {
     /// #[pyclass(sequence)]
     const IS_SEQUENCE: bool = false;
 
+    /// #[pyclass(immutable_type)]
+    const IS_IMMUTABLE_TYPE: bool = false;
+
     /// Base class
     type BaseType: PyTypeInfo + PyClassBaseType;
 
@@ -1103,8 +1106,7 @@ impl ThreadCheckerImpl {
         assert_eq!(
             thread::current().id(),
             self.0,
-            "{} is unsendable, but sent to another thread",
-            type_name
+            "{type_name} is unsendable, but sent to another thread"
         );
     }
 
@@ -1115,8 +1117,7 @@ impl ThreadCheckerImpl {
     fn can_drop(&self, py: Python<'_>, type_name: &'static str) -> bool {
         if thread::current().id() != self.0 {
             PyRuntimeError::new_err(format!(
-                "{} is unsendable, but is being dropped on another thread",
-                type_name
+                "{type_name} is unsendable, but is being dropped on another thread"
             ))
             .write_unraisable(py, None);
             return false;
diff --git a/src/impl_/pyclass/lazy_type_object.rs b/src/impl_/pyclass/lazy_type_object.rs
index d3bede7b2f3..ac4aa3fd3d9 100644
--- a/src/impl_/pyclass/lazy_type_object.rs
+++ b/src/impl_/pyclass/lazy_type_object.rs
@@ -4,6 +4,10 @@ use std::{
     thread::{self, ThreadId},
 };
 
+#[cfg(Py_3_14)]
+use crate::err::error_on_minusone;
+#[cfg(Py_3_14)]
+use crate::types::PyTypeMethods;
 use crate::{
     exceptions::PyRuntimeError,
     ffi,
@@ -75,19 +79,20 @@ impl LazyTypeObjectInner {
         items_iter: PyClassItemsIter,
     ) -> PyResult<&Bound<'py, PyType>> {
         (|| -> PyResult<_> {
-            let type_object = self
-                .value
-                .get_or_try_init(py, || init(py))?
-                .type_object
-                .bind(py);
-            self.ensure_init(type_object, name, items_iter)?;
+            let PyClassTypeObject {
+                type_object,
+                is_immutable_type,
+                ..
+            } = self.value.get_or_try_init(py, || init(py))?;
+            let type_object = type_object.bind(py);
+            self.ensure_init(type_object, *is_immutable_type, name, items_iter)?;
             Ok(type_object)
         })()
         .map_err(|err| {
             wrap_in_runtime_error(
                 py,
                 err,
-                format!("An error occurred while initializing class {}", name),
+                format!("An error occurred while initializing class {name}"),
             )
         })
     }
@@ -95,6 +100,7 @@ impl LazyTypeObjectInner {
     fn ensure_init(
         &self,
         type_object: &Bound<'_, PyType>,
+        #[allow(unused_variables)] is_immutable_type: bool,
         name: &str,
         items_iter: PyClassItemsIter,
     ) -> PyResult<()> {
@@ -181,6 +187,28 @@ impl LazyTypeObjectInner {
         // return from the function.
         let result = self.tp_dict_filled.get_or_try_init(py, move || {
             let result = initialize_tp_dict(py, type_object.as_ptr(), items);
+            #[cfg(Py_3_14)]
+            if is_immutable_type {
+                // freeze immutable types after __dict__ is initialized
+                let res = unsafe { ffi::PyType_Freeze(type_object.as_type_ptr()) };
+                error_on_minusone(py, res)?;
+            }
+            #[cfg(all(Py_3_10, not(Py_LIMITED_API), not(Py_3_14)))]
+            if is_immutable_type {
+                use crate::types::PyTypeMethods as _;
+                #[cfg(not(Py_GIL_DISABLED))]
+                unsafe {
+                    (*type_object.as_type_ptr()).tp_flags |= ffi::Py_TPFLAGS_IMMUTABLETYPE
+                };
+                #[cfg(Py_GIL_DISABLED)]
+                unsafe {
+                    (*type_object.as_type_ptr()).tp_flags.fetch_or(
+                        ffi::Py_TPFLAGS_IMMUTABLETYPE,
+                        std::sync::atomic::Ordering::Relaxed,
+                    )
+                };
+                unsafe { ffi::PyType_Modified(type_object.as_type_ptr()) };
+            }
 
             // Initialization successfully complete, can clear the thread list.
             // (No further calls to get_or_init() will try to init, on any thread.)
@@ -196,7 +224,7 @@ impl LazyTypeObjectInner {
             return Err(wrap_in_runtime_error(
                 py,
                 err.clone_ref(py),
-                format!("An error occurred while initializing `{}.__dict__`", name),
+                format!("An error occurred while initializing `{name}.__dict__`"),
             ));
         }
 
diff --git a/src/inspect/types.rs b/src/inspect/types.rs
index 50674ce96f9..b0159f71af0 100644
--- a/src/inspect/types.rs
+++ b/src/inspect/types.rs
@@ -212,7 +212,7 @@ impl Display for TypeInfo {
                         if comma {
                             write!(f, ", ")?;
                         }
-                        write!(f, "{}", arg)?;
+                        write!(f, "{arg}")?;
                         comma = true;
                     }
                     write!(f, "]")?;
@@ -220,7 +220,7 @@ impl Display for TypeInfo {
                     write!(f, "...")?;
                 }
 
-                write!(f, ", {}]", output)
+                write!(f, ", {output}]")
             }
             TypeInfo::Tuple(types) => {
                 write!(f, "Tuple[")?;
@@ -234,7 +234,7 @@ impl Display for TypeInfo {
                             if comma {
                                 write!(f, ", ")?;
                             }
-                            write!(f, "{}", t)?;
+                            write!(f, "{t}")?;
                             comma = true;
                         }
                     }
@@ -244,11 +244,11 @@ impl Display for TypeInfo {
 
                 write!(f, "]")
             }
-            TypeInfo::UnsizedTypedTuple(t) => write!(f, "Tuple[{}, ...]", t),
+            TypeInfo::UnsizedTypedTuple(t) => write!(f, "Tuple[{t}, ...]"),
             TypeInfo::Class {
                 name, type_vars, ..
             } => {
-                write!(f, "{}", name)?;
+                write!(f, "{name}")?;
 
                 if !type_vars.is_empty() {
                     write!(f, "[")?;
@@ -258,7 +258,7 @@ impl Display for TypeInfo {
                         if comma {
                             write!(f, ", ")?;
                         }
-                        write!(f, "{}", var)?;
+                        write!(f, "{var}")?;
                         comma = true;
                     }
 
@@ -279,7 +279,7 @@ mod test {
 
     #[track_caller]
     pub fn assert_display(t: &TypeInfo, expected: &str) {
-        assert_eq!(format!("{}", t), expected)
+        assert_eq!(format!("{t}"), expected)
     }
 
     #[test]
diff --git a/src/instance.rs b/src/instance.rs
index ce746eb2f36..8dc6a2e73c1 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -7,8 +7,8 @@ use crate::pyclass::boolean_struct::{False, True};
 use crate::types::{any::PyAnyMethods, string::PyStringMethods, typeobject::PyTypeMethods};
 use crate::types::{DerefToPyAny, PyDict, PyString, PyTuple};
 use crate::{
-    ffi, AsPyPointer, DowncastError, FromPyObject, PyAny, PyClass, PyClassInitializer, PyRef,
-    PyRefMut, PyTypeInfo, Python,
+    ffi, DowncastError, FromPyObject, PyAny, PyClass, PyClassInitializer, PyRef, PyRefMut,
+    PyTypeInfo, Python,
 };
 use crate::{gil, PyTypeCheck};
 use std::marker::PhantomData;
@@ -497,7 +497,7 @@ fn python_format(
     }
 
     match any.get_type().name() {
-        Result::Ok(name) => std::write!(f, "<unprintable {} object>", name),
+        Result::Ok(name) => std::write!(f, "<unprintable {name} object>"),
         Result::Err(_err) => f.write_str("<unprintable object>"),
     }
 }
@@ -524,6 +524,13 @@ impl<'py, T> AsRef<Bound<'py, PyAny>> for Bound<'py, T> {
     }
 }
 
+impl<T> AsRef<Py<PyAny>> for Bound<'_, T> {
+    #[inline]
+    fn as_ref(&self) -> &Py<PyAny> {
+        self.as_any().as_unbound()
+    }
+}
+
 impl<T> Clone for Bound<'_, T> {
     #[inline]
     fn clone(&self) -> Self {
@@ -612,13 +619,6 @@ impl<'py, T> Bound<'py, T> {
     }
 }
 
-unsafe impl<T> AsPyPointer for Bound<'_, T> {
-    #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.1.as_ptr()
-    }
-}
-
 impl<'py, T> BoundObject<'py, T> for Bound<'py, T> {
     type Any = Bound<'py, PyAny>;
 
@@ -801,6 +801,13 @@ impl<'a, 'py, T> From<&'a Bound<'py, T>> for Borrowed<'a, 'py, T> {
     }
 }
 
+impl<T> AsRef<Py<PyAny>> for Borrowed<'_, '_, T> {
+    #[inline]
+    fn as_ref(&self) -> &Py<PyAny> {
+        self.as_any().as_unbound()
+    }
+}
+
 impl<T> std::fmt::Debug for Borrowed<'_, '_, T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Bound::fmt(self, f)
@@ -1315,8 +1322,8 @@ impl<T> Py<T> {
     ///
     /// This is equivalent to the Python expression `self is other`.
     #[inline]
-    pub fn is<U: AsPyPointer>(&self, o: &U) -> bool {
-        ptr::eq(self.as_ptr(), o.as_ptr())
+    pub fn is<U: AsRef<Py<PyAny>>>(&self, o: U) -> bool {
+        ptr::eq(self.as_ptr(), o.as_ref().as_ptr())
     }
 
     /// Gets the reference count of the `ffi::PyObject` pointer.
@@ -1692,11 +1699,10 @@ impl<T> Py<T> {
     }
 }
 
-unsafe impl<T> crate::AsPyPointer for Py<T> {
-    /// Gets the underlying FFI pointer, returns a borrowed pointer.
+impl<T> AsRef<Py<PyAny>> for Py<T> {
     #[inline]
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.0.as_ptr()
+    fn as_ref(&self) -> &Py<PyAny> {
+        self.as_any()
     }
 }
 
@@ -2102,7 +2108,7 @@ a = A()
     fn test_debug_fmt() {
         Python::with_gil(|py| {
             let obj = "hello world".into_pyobject(py).unwrap();
-            assert_eq!(format!("{:?}", obj), "'hello world'");
+            assert_eq!(format!("{obj:?}"), "'hello world'");
         });
     }
 
@@ -2110,7 +2116,7 @@ a = A()
     fn test_display_fmt() {
         Python::with_gil(|py| {
             let obj = "hello world".into_pyobject(py).unwrap();
-            assert_eq!(format!("{}", obj), "hello world");
+            assert_eq!(format!("{obj}"), "hello world");
         });
     }
 
@@ -2146,6 +2152,17 @@ a = A()
         });
     }
 
+    #[test]
+    fn test_borrowed_identity() {
+        Python::with_gil(|py| {
+            let yes = true.into_pyobject(py).unwrap();
+            let no = false.into_pyobject(py).unwrap();
+
+            assert!(yes.is(yes));
+            assert!(!yes.is(no));
+        });
+    }
+
     #[test]
     fn bound_from_borrowed_ptr_constructors() {
         // More detailed tests of the underlying semantics in pycell.rs
diff --git a/src/lib.rs b/src/lib.rs
index e7e99318e2a..8d684b67c18 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -114,6 +114,7 @@
 //! - [`num-complex`]: Enables conversions between Python objects and [num-complex]'s [`Complex`]
 //!  type.
 //! - [`num-rational`]: Enables conversions between Python's fractions.Fraction and [num-rational]'s types
+//! - [`ordered-float`]: Enables conversions between Python's float and [ordered-float]'s types
 //! - [`rust_decimal`]: Enables conversions between Python's decimal.Decimal and [rust_decimal]'s
 //! [`Decimal`] type.
 //! - [`serde`]: Allows implementing [serde]'s [`Serialize`] and [`Deserialize`] traits for
@@ -311,6 +312,7 @@
 //! [`num-bigint`]: ./num_bigint/index.html "Documentation about the `num-bigint` feature."
 //! [`num-complex`]: ./num_complex/index.html "Documentation about the `num-complex` feature."
 //! [`num-rational`]: ./num_rational/index.html "Documentation about the `num-rational` feature."
+//! [`ordered-float`]: ./ordered_float/index.html "Documentation about the `ordered-float` feature."
 //! [`pyo3-build-config`]: https://docs.rs/pyo3-build-config
 //! [rust_decimal]: https://docs.rs/rust_decimal
 //! [`rust_decimal`]: ./rust_decimal/index.html "Documenation about the `rust_decimal` feature."
@@ -328,6 +330,7 @@
 //! [num-bigint]: https://docs.rs/num-bigint
 //! [num-complex]: https://docs.rs/num-complex
 //! [num-rational]: https://docs.rs/num-rational
+//! [ordered-float]: https://docs.rs/ordered-float
 //! [serde]: https://docs.rs/serde
 //! [setuptools-rust]: https://github.com/PyO3/setuptools-rust "Setuptools plugin for Rust extensions"
 //! [the guide]: https://pyo3.rs "PyO3 user guide"
@@ -338,7 +341,7 @@
 #![doc = concat!("[Features chapter of the guide]: https://pyo3.rs/v", env!("CARGO_PKG_VERSION"), "/features.html#features-reference \"Features Reference - PyO3 user guide\"")]
 //! [`Ungil`]: crate::marker::Ungil
 pub use crate::class::*;
-pub use crate::conversion::{AsPyPointer, FromPyObject, IntoPyObject, IntoPyObjectExt};
+pub use crate::conversion::{FromPyObject, IntoPyObject, IntoPyObjectExt};
 pub use crate::err::{DowncastError, DowncastIntoError, PyErr, PyErrArguments, PyResult, ToPyErr};
 #[cfg(not(any(PyPy, GraalPy)))]
 pub use crate::gil::{prepare_freethreaded_python, with_embedded_python_interpreter};
diff --git a/src/marker.rs b/src/marker.rs
index a4a7be8c0c5..fdc7b32ec00 100644
--- a/src/marker.rs
+++ b/src/marker.rs
@@ -399,6 +399,7 @@ impl Python<'_> {
     ///
     /// [`auto-initialize`]: https://pyo3.rs/main/features.html#auto-initialize
     #[inline]
+    #[track_caller]
     pub fn with_gil<F, R>(f: F) -> R
     where
         F: for<'py> FnOnce(Python<'py>) -> R,
@@ -433,6 +434,7 @@ impl Python<'_> {
     ///
     /// Behavior in other scenarios is not documented.
     #[inline]
+    #[track_caller]
     pub unsafe fn with_gil_unchecked<F, R>(f: F) -> R
     where
         F: for<'py> FnOnce(Python<'py>) -> R,
diff --git a/src/pycell.rs b/src/pycell.rs
index 1b7463a5941..ff279000daf 100644
--- a/src/pycell.rs
+++ b/src/pycell.rs
@@ -193,7 +193,7 @@
 //! [guide]: https://pyo3.rs/latest/class.html#pycell-and-interior-mutability "PyCell and interior mutability"
 //! [Interior Mutability]: https://doc.rust-lang.org/book/ch15-05-interior-mutability.html "RefCell<T> and the Interior Mutability Pattern - The Rust Programming Language"
 
-use crate::conversion::{AsPyPointer, IntoPyObject};
+use crate::conversion::IntoPyObject;
 use crate::exceptions::PyRuntimeError;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::internal_tricks::{ptr_from_mut, ptr_from_ref};
@@ -467,12 +467,6 @@ impl<'a, 'py, T: PyClass> IntoPyObject<'py> for &'a PyRef<'py, T> {
     }
 }
 
-unsafe impl<T: PyClass> AsPyPointer for PyRef<'_, T> {
-    fn as_ptr(&self) -> *mut ffi::PyObject {
-        self.inner.as_ptr()
-    }
-}
-
 impl<T: PyClass + fmt::Debug> fmt::Debug for PyRef<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&**self, f)
diff --git a/src/pyclass/create_type_object.rs b/src/pyclass/create_type_object.rs
index bbc3e465772..a507399a462 100644
--- a/src/pyclass/create_type_object.rs
+++ b/src/pyclass/create_type_object.rs
@@ -23,6 +23,7 @@ use std::{
 
 pub(crate) struct PyClassTypeObject {
     pub type_object: Py<PyType>,
+    pub is_immutable_type: bool,
     #[allow(dead_code)] // This is purely a cache that must live as long as the type object
     getset_destructors: Vec<GetSetDefDestructor>,
 }
@@ -40,6 +41,7 @@ where
         dealloc_with_gc: unsafe extern "C" fn(*mut ffi::PyObject),
         is_mapping: bool,
         is_sequence: bool,
+        is_immutable_type: bool,
         doc: &'static CStr,
         dict_offset: Option<ffi::Py_ssize_t>,
         weaklist_offset: Option<ffi::Py_ssize_t>,
@@ -61,6 +63,7 @@ where
                 tp_dealloc_with_gc: dealloc_with_gc,
                 is_mapping,
                 is_sequence,
+                is_immutable_type,
                 has_new: false,
                 has_dealloc: false,
                 has_getitem: false,
@@ -88,6 +91,7 @@ where
             tp_dealloc_with_gc::<T>,
             T::IS_MAPPING,
             T::IS_SEQUENCE,
+            T::IS_IMMUTABLE_TYPE,
             T::doc(py)?,
             T::dict_offset(),
             T::weaklist_offset(),
@@ -116,6 +120,7 @@ struct PyTypeBuilder {
     tp_dealloc_with_gc: ffi::destructor,
     is_mapping: bool,
     is_sequence: bool,
+    is_immutable_type: bool,
     has_new: bool,
     has_dealloc: bool,
     has_getitem: bool,
@@ -446,8 +451,7 @@ impl PyTypeBuilder {
 
         if self.has_clear && !self.has_traverse {
             return Err(PyTypeError::new_err(format!(
-                "`#[pyclass]` {} implements __clear__ without __traverse__",
-                name
+                "`#[pyclass]` {name} implements __clear__ without __traverse__"
             )));
         }
 
@@ -505,6 +509,7 @@ impl PyTypeBuilder {
 
         Ok(PyClassTypeObject {
             type_object,
+            is_immutable_type: self.is_immutable_type,
             getset_destructors,
         })
     }
@@ -556,8 +561,7 @@ unsafe extern "C" fn no_constructor_defined(
                 .name()
                 .map_or_else(|_| "<unknown>".into(), |name| name.to_string());
             Err(crate::exceptions::PyTypeError::new_err(format!(
-                "No constructor defined for {}",
-                name
+                "No constructor defined for {name}"
             )))
         })
     }
diff --git a/src/pyclass/gc.rs b/src/pyclass/gc.rs
index b95bfa3804f..b4c0c994de4 100644
--- a/src/pyclass/gc.rs
+++ b/src/pyclass/gc.rs
@@ -3,7 +3,7 @@ use std::{
     os::raw::{c_int, c_void},
 };
 
-use crate::{ffi, AsPyPointer};
+use crate::{ffi, Py};
 
 /// Error returned by a `__traverse__` visitor implementation.
 #[repr(transparent)]
@@ -27,11 +27,16 @@ pub struct PyVisit<'a> {
 
 impl PyVisit<'_> {
     /// Visit `obj`.
-    pub fn call<T>(&self, obj: &T) -> Result<(), PyTraverseError>
+    ///
+    /// Note: `obj` accepts a variety of types, including
+    /// - `&Py<T>`
+    /// - `&Option<Py<T>>`
+    /// - `Option<&Py<T>>`
+    pub fn call<'a, T, U: 'a>(&self, obj: T) -> Result<(), PyTraverseError>
     where
-        T: AsPyPointer,
+        T: Into<Option<&'a Py<U>>>,
     {
-        let ptr = obj.as_ptr();
+        let ptr = obj.into().map_or_else(std::ptr::null_mut, Py::as_ptr);
         if !ptr.is_null() {
             match NonZeroCInt::new(unsafe { (self.visit)(ptr, self.arg) }) {
                 None => Ok(()),
diff --git a/src/sealed.rs b/src/sealed.rs
index 2c715468047..29ffa951f4e 100644
--- a/src/sealed.rs
+++ b/src/sealed.rs
@@ -1,7 +1,7 @@
 use crate::types::{
     PyBool, PyByteArray, PyBytes, PyCapsule, PyComplex, PyDict, PyFloat, PyFrozenSet, PyList,
-    PyMapping, PyMappingProxy, PyModule, PySequence, PySet, PySlice, PyString, PyTraceback,
-    PyTuple, PyType, PyWeakref, PyWeakrefProxy, PyWeakrefReference,
+    PyMapping, PyMappingProxy, PyModule, PyRange, PySequence, PySet, PySlice, PyString,
+    PyTraceback, PyTuple, PyType, PyWeakref, PyWeakrefProxy, PyWeakrefReference,
 };
 use crate::{ffi, Bound, PyAny, PyResult};
 
@@ -35,6 +35,7 @@ impl Sealed for Bound<'_, PyList> {}
 impl Sealed for Bound<'_, PyMapping> {}
 impl Sealed for Bound<'_, PyMappingProxy> {}
 impl Sealed for Bound<'_, PyModule> {}
+impl Sealed for Bound<'_, PyRange> {}
 impl Sealed for Bound<'_, PySequence> {}
 impl Sealed for Bound<'_, PySet> {}
 impl Sealed for Bound<'_, PySlice> {}
@@ -56,3 +57,9 @@ impl<T: crate::pyclass::PyClass> Sealed for PyClassInitializer<T> {}
 
 impl Sealed for std::sync::Once {}
 impl<T> Sealed for std::sync::Mutex<T> {}
+#[cfg(feature = "lock_api")]
+impl<R, T> Sealed for lock_api::Mutex<R, T> {}
+#[cfg(feature = "parking_lot")]
+impl Sealed for parking_lot::Once {}
+#[cfg(feature = "arc_lock")]
+impl<R: lock_api::RawMutex, T> Sealed for std::sync::Arc<lock_api::Mutex<R, T>> {}
diff --git a/src/sync.rs b/src/sync.rs
index 193cc79b105..e1a74eae7bd 100644
--- a/src/sync.rs
+++ b/src/sync.rs
@@ -536,13 +536,16 @@ mod once_lock_ext_sealed {
 /// Helper trait for `Once` to help avoid deadlocking when using a `Once` when attached to a
 /// Python thread.
 pub trait OnceExt: Sealed {
+    ///The state of `Once`
+    type OnceState;
+
     /// Similar to [`call_once`][Once::call_once], but releases the Python GIL temporarily
     /// if blocking on another thread currently calling this `Once`.
     fn call_once_py_attached(&self, py: Python<'_>, f: impl FnOnce());
 
     /// Similar to [`call_once_force`][Once::call_once_force], but releases the Python GIL
     /// temporarily if blocking on another thread currently calling this `Once`.
-    fn call_once_force_py_attached(&self, py: Python<'_>, f: impl FnOnce(&OnceState));
+    fn call_once_force_py_attached(&self, py: Python<'_>, f: impl FnOnce(&Self::OnceState));
 }
 
 /// Extension trait for [`std::sync::OnceLock`] which helps avoid deadlocks between the Python
@@ -565,7 +568,10 @@ pub trait OnceLockExt<T>: once_lock_ext_sealed::Sealed {
 
 /// Extension trait for [`std::sync::Mutex`] which helps avoid deadlocks between
 /// the Python interpreter and acquiring the `Mutex`.
-pub trait MutexExt<T>: Sealed {
+pub trait MutexExt<'a, T, R>: Sealed
+where
+    Self: 'a,
+{
     /// Lock this `Mutex` in a manner that cannot deadlock with the Python interpreter.
     ///
     /// Before attempting to lock the mutex, this function detaches from the
@@ -573,13 +579,12 @@ pub trait MutexExt<T>: Sealed {
     /// runtime before returning the `LockResult`. This avoids deadlocks between
     /// the GIL and other global synchronization events triggered by the Python
     /// interpreter.
-    fn lock_py_attached(
-        &self,
-        py: Python<'_>,
-    ) -> std::sync::LockResult<std::sync::MutexGuard<'_, T>>;
+    fn lock_py_attached(&'a self, py: Python<'_>) -> R;
 }
 
 impl OnceExt for Once {
+    type OnceState = OnceState;
+
     fn call_once_py_attached(&self, py: Python<'_>, f: impl FnOnce()) {
         if self.is_completed() {
             return;
@@ -597,6 +602,41 @@ impl OnceExt for Once {
     }
 }
 
+#[cfg(feature = "parking_lot")]
+impl OnceExt for parking_lot::Once {
+    type OnceState = parking_lot::OnceState;
+
+    fn call_once_py_attached(&self, _py: Python<'_>, f: impl FnOnce()) {
+        if self.state().done() {
+            return;
+        }
+
+        let ts_guard = unsafe { SuspendGIL::new() };
+
+        self.call_once(move || {
+            drop(ts_guard);
+            f();
+        });
+    }
+
+    fn call_once_force_py_attached(
+        &self,
+        _py: Python<'_>,
+        f: impl FnOnce(&parking_lot::OnceState),
+    ) {
+        if self.state().done() {
+            return;
+        }
+
+        let ts_guard = unsafe { SuspendGIL::new() };
+
+        self.call_once_force(move |state| {
+            drop(ts_guard);
+            f(&state);
+        });
+    }
+}
+
 #[cfg(rustc_has_once_lock)]
 impl<T> OnceLockExt<T> for std::sync::OnceLock<T> {
     fn get_or_init_py_attached<F>(&self, py: Python<'_>, f: F) -> &T
@@ -612,11 +652,13 @@ impl<T> OnceLockExt<T> for std::sync::OnceLock<T> {
     }
 }
 
-impl<T> MutexExt<T> for std::sync::Mutex<T> {
+impl<'a, T> MutexExt<'a, T, std::sync::LockResult<std::sync::MutexGuard<'a, T>>>
+    for std::sync::Mutex<T>
+{
     fn lock_py_attached(
-        &self,
+        &'a self,
         _py: Python<'_>,
-    ) -> std::sync::LockResult<std::sync::MutexGuard<'_, T>> {
+    ) -> std::sync::LockResult<std::sync::MutexGuard<'a, T>> {
         // If try_lock is successful or returns a poisoned mutex, return them so
         // the caller can deal with them. Otherwise we need to use blocking
         // lock, which requires detaching from the Python runtime to avoid
@@ -638,6 +680,41 @@ impl<T> MutexExt<T> for std::sync::Mutex<T> {
     }
 }
 
+#[cfg(feature = "lock_api")]
+impl<'a, R: lock_api::RawMutex, T> MutexExt<'a, T, lock_api::MutexGuard<'a, R, T>>
+    for lock_api::Mutex<R, T>
+{
+    fn lock_py_attached(&'a self, _py: Python<'_>) -> lock_api::MutexGuard<'a, R, T> {
+        if let Some(guard) = self.try_lock() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendGIL::new() };
+        let res = self.lock();
+        drop(ts_guard);
+        res
+    }
+}
+
+#[cfg(feature = "arc_lock")]
+impl<'a, R, T> MutexExt<'a, T, lock_api::ArcMutexGuard<R, T>>
+    for std::sync::Arc<lock_api::Mutex<R, T>>
+where
+    R: lock_api::RawMutex,
+    Self: 'a,
+{
+    fn lock_py_attached(&self, _py: Python<'_>) -> lock_api::ArcMutexGuard<R, T> {
+        if let Some(guard) = self.try_lock_arc() {
+            return guard;
+        }
+
+        let ts_guard = unsafe { SuspendGIL::new() };
+        let res = self.lock_arc();
+        drop(ts_guard);
+        res
+    }
+}
+
 #[cold]
 fn init_once_py_attached<F, T>(once: &Once, _py: Python<'_>, f: F)
 where
@@ -966,36 +1043,47 @@ mod tests {
     #[test]
     #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
     fn test_once_ext() {
-        // adapted from the example in the docs for Once::try_once_force
-        let init = Once::new();
-        std::thread::scope(|s| {
-            // poison the once
-            let handle = s.spawn(|| {
-                Python::with_gil(|py| {
-                    init.call_once_py_attached(py, || panic!());
-                })
-            });
-            assert!(handle.join().is_err());
+        macro_rules! test_once {
+            ($once:expr, $is_poisoned:expr) => {{
+                // adapted from the example in the docs for Once::try_once_force
+                let init = $once;
+                std::thread::scope(|s| {
+                    // poison the once
+                    let handle = s.spawn(|| {
+                        Python::with_gil(|py| {
+                            init.call_once_py_attached(py, || panic!());
+                        })
+                    });
+                    assert!(handle.join().is_err());
 
-            // poisoning propagates
-            let handle = s.spawn(|| {
-                Python::with_gil(|py| {
-                    init.call_once_py_attached(py, || {});
-                });
-            });
+                    // poisoning propagates
+                    let handle = s.spawn(|| {
+                        Python::with_gil(|py| {
+                            init.call_once_py_attached(py, || {});
+                        });
+                    });
+
+                    assert!(handle.join().is_err());
 
-            assert!(handle.join().is_err());
+                    // call_once_force will still run and reset the poisoned state
+                    Python::with_gil(|py| {
+                        init.call_once_force_py_attached(py, |state| {
+                            assert!($is_poisoned(state.clone()));
+                        });
 
-            // call_once_force will still run and reset the poisoned state
-            Python::with_gil(|py| {
-                init.call_once_force_py_attached(py, |state| {
-                    assert!(state.is_poisoned());
+                        // once any success happens, we stop propagating the poison
+                        init.call_once_py_attached(py, || {});
+                    });
+
+                    // calling call_once_force should return immediately without calling the closure
+                    Python::with_gil(|py| init.call_once_force_py_attached(py, |_| panic!()));
                 });
+            }};
+        }
 
-                // once any success happens, we stop propagating the poison
-                init.call_once_py_attached(py, || {});
-            });
-        });
+        test_once!(Once::new(), OnceState::is_poisoned);
+        #[cfg(feature = "parking_lot")]
+        test_once!(parking_lot::Once::new(), parking_lot::OnceState::poisoned);
     }
 
     #[cfg(rustc_has_once_lock)]
@@ -1047,6 +1135,54 @@ mod tests {
         });
     }
 
+    #[cfg(feature = "macros")]
+    #[cfg(all(
+        any(feature = "parking_lot", feature = "lock_api"),
+        not(target_arch = "wasm32") // We are building wasm Python with pthreads disabled
+    ))]
+    #[test]
+    fn test_parking_lot_mutex_ext() {
+        macro_rules! test_mutex {
+            ($guard:ty ,$mutex:stmt) => {{
+                let barrier = Barrier::new(2);
+
+                let mutex = Python::with_gil({ $mutex });
+
+                std::thread::scope(|s| {
+                    s.spawn(|| {
+                        Python::with_gil(|py| {
+                            let b: $guard = mutex.lock_py_attached(py);
+                            barrier.wait();
+                            // sleep to ensure the other thread actually blocks
+                            std::thread::sleep(std::time::Duration::from_millis(10));
+                            (*b).bind(py).borrow().0.store(true, Ordering::Release);
+                            drop(b);
+                        });
+                    });
+                    s.spawn(|| {
+                        barrier.wait();
+                        Python::with_gil(|py| {
+                            // blocks until the other thread releases the lock
+                            let b: $guard = mutex.lock_py_attached(py);
+                            assert!((*b).bind(py).borrow().0.load(Ordering::Acquire));
+                        });
+                    });
+                });
+            }};
+        }
+
+        test_mutex!(parking_lot::MutexGuard<'_, _>, |py| {
+            parking_lot::Mutex::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap())
+        });
+
+        #[cfg(feature = "arc_lock")]
+        test_mutex!(parking_lot::ArcMutexGuard<_, _>, |py| {
+            let mutex =
+                parking_lot::Mutex::new(Py::new(py, BoolWrapper(AtomicBool::new(false))).unwrap());
+            std::sync::Arc::new(mutex)
+        });
+    }
+
     #[cfg(not(target_arch = "wasm32"))] // We are building wasm Python with pthreads disabled
     #[test]
     fn test_mutex_ext_poison() {
diff --git a/src/tests/hygiene/misc.rs b/src/tests/hygiene/misc.rs
index a953cea4a24..e2e584c18a4 100644
--- a/src/tests/hygiene/misc.rs
+++ b/src/tests/hygiene/misc.rs
@@ -31,7 +31,7 @@ fn intern(py: crate::Python<'_>) {
     let _bar = crate::intern!(py, stringify!(bar));
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 fn append_to_inittab() {
     #[crate::pymodule]
     #[pyo3(crate = "crate")]
diff --git a/src/tests/hygiene/pymodule.rs b/src/tests/hygiene/pymodule.rs
index 576cc75e0d2..56c6f10fa20 100644
--- a/src/tests/hygiene/pymodule.rs
+++ b/src/tests/hygiene/pymodule.rs
@@ -33,4 +33,7 @@ fn my_module(m: &crate::Bound<'_, crate::types::PyModule>) -> crate::PyResult<()
 mod my_module_declarative {
     #[pymodule_export]
     use super::{do_something, foo};
+
+    #[pymodule_export]
+    const BAR: u32 = 42;
 }
diff --git a/src/types/any.rs b/src/types/any.rs
index 6308804c80a..936c9d07040 100644
--- a/src/types/any.rs
+++ b/src/types/any.rs
@@ -1,6 +1,6 @@
 use crate::call::PyCallArgs;
 use crate::class::basic::CompareOp;
-use crate::conversion::{AsPyPointer, FromPyObjectBound, IntoPyObject};
+use crate::conversion::{FromPyObjectBound, IntoPyObject};
 use crate::err::{DowncastError, DowncastIntoError, PyErr, PyResult};
 use crate::exceptions::{PyAttributeError, PyTypeError};
 use crate::ffi_ptr_ext::FfiPtrExt;
@@ -12,7 +12,7 @@ use crate::type_object::{PyTypeCheck, PyTypeInfo};
 #[cfg(not(any(PyPy, GraalPy)))]
 use crate::types::PySuper;
 use crate::types::{PyDict, PyIterator, PyList, PyString, PyType};
-use crate::{err, ffi, Borrowed, BoundObject, IntoPyObjectExt, Python};
+use crate::{err, ffi, Borrowed, BoundObject, IntoPyObjectExt, Py, Python};
 use std::cell::UnsafeCell;
 use std::cmp::Ordering;
 use std::os::raw::c_int;
@@ -65,7 +65,7 @@ pub trait PyAnyMethods<'py>: crate::sealed::Sealed {
     /// the equality of two objects (the `==` operator), use [`eq`](PyAnyMethods::eq).
     ///
     /// This is equivalent to the Python expression `self is other`.
-    fn is<T: AsPyPointer>(&self, other: &T) -> bool;
+    fn is<T: AsRef<Py<PyAny>>>(&self, other: T) -> bool;
 
     /// Determines whether this object has the given attribute.
     ///
@@ -951,8 +951,8 @@ macro_rules! implement_binop {
 
 impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     #[inline]
-    fn is<T: AsPyPointer>(&self, other: &T) -> bool {
-        ptr::eq(self.as_ptr(), other.as_ptr())
+    fn is<T: AsRef<Py<PyAny>>>(&self, other: T) -> bool {
+        ptr::eq(self.as_ptr(), other.as_ref().as_ptr())
     }
 
     fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>
@@ -1029,7 +1029,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
                     Err(err) => {
                         let err_type = err
                             .get_type(any.py())
-                            .is(&PyType::new::<PyAttributeError>(any.py()));
+                            .is(PyType::new::<PyAttributeError>(any.py()));
                         match err_type {
                             true => Ok(None),
                             false => Err(err),
@@ -1868,7 +1868,7 @@ class SimpleClass:
 
         Python::with_gil(|py| {
             let obj = Py::new(py, GetattrFail).unwrap();
-            let obj = obj.bind(py).as_ref();
+            let obj = obj.bind(py).as_any();
 
             assert!(obj
                 .hasattr("foo")
diff --git a/src/types/bytes.rs b/src/types/bytes.rs
index 4e2ce9c96e7..16e0c42f8b1 100644
--- a/src/types/bytes.rs
+++ b/src/types/bytes.rs
@@ -365,4 +365,19 @@ mod tests {
             assert_eq!(*b, py_string);
         })
     }
+
+    #[test]
+    #[cfg(not(Py_LIMITED_API))]
+    fn test_as_string() {
+        Python::with_gil(|py| {
+            let b = b"hello, world".as_slice();
+            let py_bytes = PyBytes::new(py, b);
+            unsafe {
+                assert_eq!(
+                    ffi::PyBytes_AsString(py_bytes.as_ptr()) as *const std::os::raw::c_char,
+                    ffi::PyBytes_AS_STRING(py_bytes.as_ptr()) as *const std::os::raw::c_char
+                );
+            }
+        })
+    }
 }
diff --git a/src/types/datetime.rs b/src/types/datetime.rs
index 6f1237c0eed..8690952807d 100644
--- a/src/types/datetime.rs
+++ b/src/types/datetime.rs
@@ -4,6 +4,8 @@
 //! documentation](https://docs.python.org/3/library/datetime.html)
 
 use crate::err::PyResult;
+#[cfg(not(Py_3_9))]
+use crate::exceptions::PyImportError;
 #[cfg(not(Py_LIMITED_API))]
 use crate::ffi::{
     self, PyDateTime_CAPI, PyDateTime_DATE_GET_FOLD, PyDateTime_DATE_GET_HOUR,
@@ -14,14 +16,15 @@ use crate::ffi::{
     PyDateTime_TIME_GET_MICROSECOND, PyDateTime_TIME_GET_MINUTE, PyDateTime_TIME_GET_SECOND,
     PyDate_FromTimestamp,
 };
-#[cfg(all(GraalPy, not(Py_LIMITED_API)))]
+#[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
 use crate::ffi::{PyDateTime_DATE_GET_TZINFO, PyDateTime_TIME_GET_TZINFO, Py_IsNone};
-use crate::types::any::PyAnyMethods;
+use crate::types::{any::PyAnyMethods, PyString, PyType};
 #[cfg(not(Py_LIMITED_API))]
-use crate::{ffi_ptr_ext::FfiPtrExt, py_result_ext::PyResultExt, types::PyTuple, IntoPyObject};
+use crate::{ffi_ptr_ext::FfiPtrExt, py_result_ext::PyResultExt, types::PyTuple, BoundObject};
+use crate::{sync::GILOnceCell, Py};
 #[cfg(Py_LIMITED_API)]
-use crate::{sync::GILOnceCell, types::IntoPyDict, types::PyType, Py, PyTypeCheck};
-use crate::{Bound, PyAny, PyErr, Python};
+use crate::{types::IntoPyDict, PyTypeCheck};
+use crate::{Borrowed, Bound, IntoPyObject, PyAny, PyErr, Python};
 #[cfg(not(Py_LIMITED_API))]
 use std::os::raw::c_int;
 
@@ -518,11 +521,9 @@ impl PyTimeAccess for Bound<'_, PyDateTime> {
 
 impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyDateTime> {
     fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>> {
-        #[cfg(not(Py_LIMITED_API))]
-        let ptr = self.as_ptr() as *mut ffi::PyDateTime_DateTime;
-
-        #[cfg(not(any(GraalPy, Py_LIMITED_API)))]
+        #[cfg(all(not(Py_3_10), not(Py_LIMITED_API)))]
         unsafe {
+            let ptr = self.as_ptr() as *mut ffi::PyDateTime_DateTime;
             if (*ptr).hastzinfo != 0 {
                 Some(
                     (*ptr)
@@ -536,9 +537,9 @@ impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyDateTime> {
             }
         }
 
-        #[cfg(all(GraalPy, not(Py_LIMITED_API)))]
+        #[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
         unsafe {
-            let res = PyDateTime_DATE_GET_TZINFO(ptr as *mut ffi::PyObject);
+            let res = PyDateTime_DATE_GET_TZINFO(self.as_ptr());
             if Py_IsNone(res) == 1 {
                 None
             } else {
@@ -700,11 +701,9 @@ impl PyTimeAccess for Bound<'_, PyTime> {
 
 impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyTime> {
     fn get_tzinfo(&self) -> Option<Bound<'py, PyTzInfo>> {
-        #[cfg(not(Py_LIMITED_API))]
-        let ptr = self.as_ptr() as *mut ffi::PyDateTime_Time;
-
-        #[cfg(not(any(GraalPy, Py_LIMITED_API)))]
+        #[cfg(all(not(Py_3_10), not(Py_LIMITED_API)))]
         unsafe {
+            let ptr = self.as_ptr() as *mut ffi::PyDateTime_Time;
             if (*ptr).hastzinfo != 0 {
                 Some(
                     (*ptr)
@@ -718,9 +717,9 @@ impl<'py> PyTzInfoAccess<'py> for Bound<'py, PyTime> {
             }
         }
 
-        #[cfg(all(GraalPy, not(Py_LIMITED_API)))]
+        #[cfg(all(Py_3_10, not(Py_LIMITED_API)))]
         unsafe {
-            let res = PyDateTime_TIME_GET_TZINFO(ptr as *mut ffi::PyObject);
+            let res = PyDateTime_TIME_GET_TZINFO(self.as_ptr());
             if Py_IsNone(res) == 1 {
                 None
             } else {
@@ -781,65 +780,85 @@ impl PyTypeCheck for PyTzInfo {
     }
 }
 
-/// Equivalent to `datetime.timezone.utc`
-pub fn timezone_utc(py: Python<'_>) -> Bound<'_, PyTzInfo> {
-    // TODO: this _could_ have a borrowed form `timezone_utc_borrowed`, but that seems
-    // like an edge case optimization and we'd prefer in PyO3 0.21 to use `Bound` as
-    // much as possible
-    #[cfg(not(Py_LIMITED_API))]
-    unsafe {
-        expect_datetime_api(py)
-            .TimeZone_UTC
-            .assume_borrowed(py)
-            .to_owned()
-            .downcast_into_unchecked()
+impl PyTzInfo {
+    /// Equivalent to `datetime.timezone.utc`
+    pub fn utc(py: Python<'_>) -> PyResult<Borrowed<'static, '_, PyTzInfo>> {
+        #[cfg(not(Py_LIMITED_API))]
+        unsafe {
+            Ok(ensure_datetime_api(py)?
+                .TimeZone_UTC
+                .assume_borrowed(py)
+                .downcast_unchecked())
+        }
+
+        #[cfg(Py_LIMITED_API)]
+        {
+            static UTC: GILOnceCell<Py<PyTzInfo>> = GILOnceCell::new();
+            UTC.get_or_try_init(py, || {
+                Ok(DatetimeTypes::get(py)
+                    .timezone
+                    .bind(py)
+                    .getattr("utc")?
+                    .downcast_into()?
+                    .unbind())
+            })
+            .map(|utc| utc.bind_borrowed(py))
+        }
     }
 
-    #[cfg(Py_LIMITED_API)]
+    /// Equivalent to `zoneinfo.ZoneInfo` constructor
+    pub fn timezone<'py, T>(py: Python<'py>, iana_name: T) -> PyResult<Bound<'py, PyTzInfo>>
+    where
+        T: IntoPyObject<'py, Target = PyString>,
     {
-        static UTC: GILOnceCell<Py<PyTzInfo>> = GILOnceCell::new();
-        UTC.get_or_init(py, || {
-            DatetimeTypes::get(py)
-                .timezone
-                .bind(py)
-                .getattr("utc")
-                .expect("failed to import datetime.timezone.utc")
-                .downcast_into()
-                .unwrap()
-                .unbind()
-        })
-        .bind(py)
-        .to_owned()
-    }
-}
+        static ZONE_INFO: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
-/// Equivalent to `datetime.timezone` constructor
-///
-/// Only used internally
-#[cfg(any(feature = "chrono", feature = "jiff-02"))]
-pub(crate) fn timezone_from_offset<'py>(
-    offset: &Bound<'py, PyDelta>,
-) -> PyResult<Bound<'py, PyTzInfo>> {
-    let py = offset.py();
+        let zoneinfo = ZONE_INFO.import(py, "zoneinfo", "ZoneInfo");
 
-    #[cfg(not(Py_LIMITED_API))]
+        #[cfg(not(Py_3_9))]
+        let zoneinfo = zoneinfo
+            .or_else(|_| ZONE_INFO.import(py, "backports.zoneinfo", "ZoneInfo"))
+            .map_err(|_| PyImportError::new_err("Could not import \"backports.zoneinfo.ZoneInfo\". ZoneInfo is required when converting timezone-aware DateTime's. Please install \"backports.zoneinfo\" on python < 3.9"));
+
+        zoneinfo?
+            .call1((iana_name,))?
+            .downcast_into()
+            .map_err(Into::into)
+    }
+
+    /// Equivalent to `datetime.timezone` constructor
+    pub fn fixed_offset<'py, T>(py: Python<'py>, offset: T) -> PyResult<Bound<'py, PyTzInfo>>
+    where
+        T: IntoPyObject<'py, Target = PyDelta>,
     {
-        let api = ensure_datetime_api(py)?;
+        #[cfg(not(Py_LIMITED_API))]
+        {
+            let api = ensure_datetime_api(py)?;
+            let delta = offset.into_pyobject(py).map_err(Into::into)?;
+            unsafe {
+                (api.TimeZone_FromTimeZone)(delta.as_ptr(), std::ptr::null_mut())
+                    .assume_owned_or_err(py)
+                    .downcast_into_unchecked()
+            }
+        }
+
+        #[cfg(Py_LIMITED_API)]
         unsafe {
-            (api.TimeZone_FromTimeZone)(offset.as_ptr(), std::ptr::null_mut())
-                .assume_owned_or_err(py)
-                .downcast_into_unchecked()
+            Ok(DatetimeTypes::try_get(py)?
+                .timezone
+                .bind(py)
+                .call1((offset,))?
+                .downcast_into_unchecked())
         }
     }
+}
 
-    #[cfg(Py_LIMITED_API)]
-    unsafe {
-        Ok(DatetimeTypes::try_get(py)?
-            .timezone
-            .bind(py)
-            .call1((offset,))?
-            .downcast_into_unchecked())
-    }
+/// Equivalent to `datetime.timezone.utc`
+#[deprecated(since = "0.25.0", note = "use `PyTzInfo::utc` instead")]
+pub fn timezone_utc(py: Python<'_>) -> Bound<'_, PyTzInfo> {
+    PyTzInfo::utc(py)
+        .expect("failed to import datetime.timezone.utc")
+        .to_owned()
 }
 
 /// Bindings for `datetime.timedelta`.
@@ -955,7 +974,8 @@ mod tests {
                 "import datetime; assert dt == datetime.datetime.fromtimestamp(100)"
             );
 
-            let dt = PyDateTime::from_timestamp(py, 100.0, Some(&timezone_utc(py))).unwrap();
+            let utc = PyTzInfo::utc(py).unwrap();
+            let dt = PyDateTime::from_timestamp(py, 100.0, Some(&utc)).unwrap();
             py_run!(
                 py,
                 dt,
@@ -995,11 +1015,11 @@ mod tests {
     #[cfg_attr(target_arch = "wasm32", ignore)] // DateTime import fails on wasm for mysterious reasons
     fn test_get_tzinfo() {
         crate::Python::with_gil(|py| {
-            let utc = timezone_utc(py);
+            let utc = PyTzInfo::utc(py).unwrap();
 
             let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(&utc)).unwrap();
 
-            assert!(dt.get_tzinfo().unwrap().eq(&utc).unwrap());
+            assert!(dt.get_tzinfo().unwrap().eq(utc).unwrap());
 
             let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, None).unwrap();
 
@@ -1023,7 +1043,7 @@ mod tests {
 
         Python::with_gil(|py| {
             assert!(
-                timezone_from_offset(&PyDelta::new(py, 0, -3600, 0, true).unwrap())
+                PyTzInfo::fixed_offset(py, PyDelta::new(py, 0, -3600, 0, true).unwrap())
                     .unwrap()
                     .call_method1("utcoffset", (PyNone::get(py),))
                     .unwrap()
@@ -1034,7 +1054,7 @@ mod tests {
             );
 
             assert!(
-                timezone_from_offset(&PyDelta::new(py, 0, 3600, 0, true).unwrap())
+                PyTzInfo::fixed_offset(py, PyDelta::new(py, 0, 3600, 0, true).unwrap())
                     .unwrap()
                     .call_method1("utcoffset", (PyNone::get(py),))
                     .unwrap()
@@ -1044,7 +1064,7 @@ mod tests {
                     .unwrap()
             );
 
-            timezone_from_offset(&PyDelta::new(py, 1, 0, 0, true).unwrap()).unwrap_err();
+            PyTzInfo::fixed_offset(py, PyDelta::new(py, 1, 0, 0, true).unwrap()).unwrap_err();
         })
     }
 }
diff --git a/src/types/dict.rs b/src/types/dict.rs
index 0ef5c477ae1..c38fe638d10 100644
--- a/src/types/dict.rs
+++ b/src/types/dict.rs
@@ -967,7 +967,7 @@ mod tests {
                 }
                 Err(err) => {
                     assert!(err.is_instance_of::<PyTypeError>(py));
-                    assert_eq!(err.value(py).to_string(), "Error from __hash__")
+                    assert!(err.value(py).to_string().contains("Error from __hash__"));
                 }
             }
         })
diff --git a/src/types/ellipsis.rs b/src/types/ellipsis.rs
index 19cb2d2dca9..e9c1e777463 100644
--- a/src/types/ellipsis.rs
+++ b/src/types/ellipsis.rs
@@ -60,7 +60,7 @@ mod tests {
         Python::with_gil(|py| {
             assert!(PyEllipsis::get(py)
                 .get_type()
-                .is(&PyEllipsis::type_object(py)));
+                .is(PyEllipsis::type_object(py)));
         })
     }
 
diff --git a/src/types/list.rs b/src/types/list.rs
index 7c63c5bf44d..c0edc39cbce 100644
--- a/src/types/list.rs
+++ b/src/types/list.rs
@@ -1330,7 +1330,7 @@ mod tests {
         Python::with_gil(|py| {
             let v = vec![2, 3, 5, 7];
             let list = PyList::new(py, &v).unwrap();
-            let v2 = list.as_ref().extract::<Vec<i32>>().unwrap();
+            let v2 = list.as_any().extract::<Vec<i32>>().unwrap();
             assert_eq!(v, v2);
         });
     }
diff --git a/src/types/mappingproxy.rs b/src/types/mappingproxy.rs
index 436a52dc3e9..db2a52cecbf 100644
--- a/src/types/mappingproxy.rs
+++ b/src/types/mappingproxy.rs
@@ -420,7 +420,7 @@ mod tests {
         });
     }
 
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn abc_mappingproxy(py: Python<'_>) -> Bound<'_, PyMappingProxy> {
         let mut map = HashMap::<&'static str, i32>::new();
         map.insert("a", 1);
@@ -431,7 +431,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn mappingproxy_keys_view() {
         Python::with_gil(|py| {
             let mappingproxy = abc_mappingproxy(py);
@@ -441,7 +441,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn mappingproxy_values_view() {
         Python::with_gil(|py| {
             let mappingproxy = abc_mappingproxy(py);
@@ -451,7 +451,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     fn mappingproxy_items_view() {
         Python::with_gil(|py| {
             let mappingproxy = abc_mappingproxy(py);
diff --git a/src/types/mod.rs b/src/types/mod.rs
index 9fff4cbadcb..a7101d65ced 100644
--- a/src/types/mod.rs
+++ b/src/types/mod.rs
@@ -38,6 +38,7 @@ pub use self::notimplemented::PyNotImplemented;
 pub use self::num::PyInt;
 #[cfg(not(any(PyPy, GraalPy)))]
 pub use self::pysuper::PySuper;
+pub use self::range::{PyRange, PyRangeMethods};
 pub use self::sequence::{PySequence, PySequenceMethods};
 pub use self::set::{PySet, PySetMethods};
 pub use self::slice::{PySlice, PySliceIndices, PySliceMethods};
@@ -246,6 +247,7 @@ mod notimplemented;
 mod num;
 #[cfg(not(any(PyPy, GraalPy)))]
 mod pysuper;
+pub(crate) mod range;
 pub(crate) mod sequence;
 pub(crate) mod set;
 pub(crate) mod slice;
diff --git a/src/types/none.rs b/src/types/none.rs
index 319a01a5311..71af995ad43 100644
--- a/src/types/none.rs
+++ b/src/types/none.rs
@@ -56,7 +56,7 @@ mod tests {
     #[test]
     fn test_none_type_object_consistent() {
         Python::with_gil(|py| {
-            assert!(PyNone::get(py).get_type().is(&PyNone::type_object(py)));
+            assert!(PyNone::get(py).get_type().is(PyNone::type_object(py)));
         })
     }
 
diff --git a/src/types/notimplemented.rs b/src/types/notimplemented.rs
index 040cc19db61..9e9bcb79759 100644
--- a/src/types/notimplemented.rs
+++ b/src/types/notimplemented.rs
@@ -63,7 +63,7 @@ mod tests {
         Python::with_gil(|py| {
             assert!(PyNotImplemented::get(py)
                 .get_type()
-                .is(&PyNotImplemented::type_object(py)));
+                .is(PyNotImplemented::type_object(py)));
         })
     }
 
diff --git a/src/types/num.rs b/src/types/num.rs
index 79cd800b75d..2ba92d0c742 100644
--- a/src/types/num.rs
+++ b/src/types/num.rs
@@ -139,13 +139,13 @@ mod tests {
     fn test_display_int() {
         Python::with_gil(|py| {
             let s = PyInt::new(py, 42u8);
-            assert_eq!(format!("{}", s), "42");
+            assert_eq!(format!("{s}"), "42");
 
             let s = PyInt::new(py, 43i32);
-            assert_eq!(format!("{}", s), "43");
+            assert_eq!(format!("{s}"), "43");
 
             let s = PyInt::new(py, 44usize);
-            assert_eq!(format!("{}", s), "44");
+            assert_eq!(format!("{s}"), "44");
         })
     }
 }
diff --git a/src/types/range.rs b/src/types/range.rs
new file mode 100644
index 00000000000..e499eac49f0
--- /dev/null
+++ b/src/types/range.rs
@@ -0,0 +1,92 @@
+use crate::sealed::Sealed;
+use crate::types::PyAnyMethods;
+use crate::{ffi, Bound, PyAny, PyResult, PyTypeInfo, Python};
+
+/// Represents a Python `range`.
+///
+/// Values of this type are accessed via PyO3's smart pointers, e.g. as
+/// [`Py<PyRange>`][crate::Py] or [`Bound<'py, PyRange>`][Bound].
+///
+/// For APIs available on `range` objects, see the [`PyRangeMethods`] trait which is implemented for
+/// [`Bound<'py, PyRange>`][Bound].
+#[repr(transparent)]
+pub struct PyRange(PyAny);
+
+pyobject_native_type_core!(PyRange, pyobject_native_static_type_object!(ffi::PyRange_Type), #checkfunction=ffi::PyRange_Check);
+
+impl<'py> PyRange {
+    /// Creates a new Python `range` object with a default step of 1.
+    pub fn new(py: Python<'py>, start: isize, stop: isize) -> PyResult<Bound<'py, Self>> {
+        Self::new_with_step(py, start, stop, 1)
+    }
+
+    /// Creates a new Python `range` object with a specified step.
+    pub fn new_with_step(
+        py: Python<'py>,
+        start: isize,
+        stop: isize,
+        step: isize,
+    ) -> PyResult<Bound<'py, Self>> {
+        unsafe {
+            Ok(Self::type_object(py)
+                .call1((start, stop, step))?
+                .downcast_into_unchecked())
+        }
+    }
+}
+
+/// Implementation of functionality for [`PyRange`].
+///
+/// These methods are defined for the `Bound<'py, PyRange>` smart pointer, so to use method call
+/// syntax these methods are separated into a trait, because stable Rust does not yet support
+/// `arbitrary_self_types`.
+#[doc(alias = "PyRange")]
+pub trait PyRangeMethods<'py>: Sealed {
+    /// Returns the start of the range.
+    fn start(&self) -> PyResult<isize>;
+
+    /// Returns the exclusive end of the range.
+    fn stop(&self) -> PyResult<isize>;
+
+    /// Returns the step of the range.
+    fn step(&self) -> PyResult<isize>;
+}
+
+impl<'py> PyRangeMethods<'py> for Bound<'py, PyRange> {
+    fn start(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "start"))?.extract()
+    }
+
+    fn stop(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "stop"))?.extract()
+    }
+
+    fn step(&self) -> PyResult<isize> {
+        self.getattr(intern!(self.py(), "step"))?.extract()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_py_range_new() {
+        Python::with_gil(|py| {
+            let range = PyRange::new(py, isize::MIN, isize::MAX).unwrap();
+            assert_eq!(range.start().unwrap(), isize::MIN);
+            assert_eq!(range.stop().unwrap(), isize::MAX);
+            assert_eq!(range.step().unwrap(), 1);
+        });
+    }
+
+    #[test]
+    fn test_py_range_new_with_step() {
+        Python::with_gil(|py| {
+            let range = PyRange::new_with_step(py, 1, 10, 2).unwrap();
+            assert_eq!(range.start().unwrap(), 1);
+            assert_eq!(range.stop().unwrap(), 10);
+            assert_eq!(range.step().unwrap(), 2);
+        });
+    }
+}
diff --git a/src/types/sequence.rs b/src/types/sequence.rs
index 3efd7ccff58..c5fef02bd5e 100644
--- a/src/types/sequence.rs
+++ b/src/types/sequence.rs
@@ -825,7 +825,7 @@ mod tests {
             let v = vec!["foo", "bar"];
             let ob = v.into_pyobject(py).unwrap();
             let seq = ob.downcast::<PySequence>().unwrap();
-            let type_ptr = seq.as_ref();
+            let type_ptr = seq.as_any();
             let seq_from = unsafe { type_ptr.downcast_unchecked::<PySequence>() };
             assert!(seq_from.to_list().is_ok());
         });
diff --git a/src/types/slice.rs b/src/types/slice.rs
index 97c38e0f36c..9b743156606 100644
--- a/src/types/slice.rs
+++ b/src/types/slice.rs
@@ -2,6 +2,7 @@ use crate::err::{PyErr, PyResult};
 use crate::ffi;
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::types::any::PyAnyMethods;
+use crate::types::{PyRange, PyRangeMethods};
 use crate::{Bound, IntoPyObject, PyAny, Python};
 use std::convert::Infallible;
 
@@ -140,6 +141,19 @@ impl<'py> IntoPyObject<'py> for &PySliceIndices {
     }
 }
 
+impl<'py> TryFrom<Bound<'py, PyRange>> for Bound<'py, PySlice> {
+    type Error = PyErr;
+
+    fn try_from(range: Bound<'py, PyRange>) -> Result<Self, Self::Error> {
+        Ok(PySlice::new(
+            range.py(),
+            range.start()?,
+            range.stop()?,
+            range.step()?,
+        ))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/types/string.rs b/src/types/string.rs
index a9df79c305d..774624df108 100644
--- a/src/types/string.rs
+++ b/src/types/string.rs
@@ -609,7 +609,7 @@ mod tests {
     fn test_debug_string() {
         Python::with_gil(|py| {
             let s = "Hello\n".into_pyobject(py).unwrap();
-            assert_eq!(format!("{:?}", s), "'Hello\\n'");
+            assert_eq!(format!("{s:?}"), "'Hello\\n'");
         })
     }
 
@@ -617,7 +617,7 @@ mod tests {
     fn test_display_string() {
         Python::with_gil(|py| {
             let s = "Hello\n".into_pyobject(py).unwrap();
-            assert_eq!(format!("{}", s), "Hello\n");
+            assert_eq!(format!("{s}"), "Hello\n");
         })
     }
 
@@ -647,7 +647,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs1() {
         Python::with_gil(|py| {
             let s = PyString::new(py, "hello, world");
@@ -660,7 +660,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs1_invalid() {
         Python::with_gil(|py| {
             // 0xfe is not allowed in UTF-8.
@@ -677,7 +677,7 @@ mod tests {
             let data = unsafe { s.data().unwrap() };
             assert_eq!(data, PyStringData::Ucs1(b"f\xfe"));
             let err = data.to_string(py).unwrap_err();
-            assert!(err.get_type(py).is(&py.get_type::<PyUnicodeDecodeError>()));
+            assert!(err.get_type(py).is(py.get_type::<PyUnicodeDecodeError>()));
             assert!(err
                 .to_string()
                 .contains("'utf-8' codec can't decode byte 0xfe in position 1"));
@@ -686,7 +686,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs2() {
         Python::with_gil(|py| {
             let s = py.eval(ffi::c_str!("'foo\\ud800'"), None, None).unwrap();
@@ -702,7 +702,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(all(not(any(Py_LIMITED_API, PyPy)), target_endian = "little"))]
+    #[cfg(all(not(any(Py_LIMITED_API, PyPy, GraalPy)), target_endian = "little"))]
     fn test_string_data_ucs2_invalid() {
         Python::with_gil(|py| {
             // U+FF22 (valid) & U+d800 (never valid)
@@ -719,7 +719,7 @@ mod tests {
             let data = unsafe { s.data().unwrap() };
             assert_eq!(data, PyStringData::Ucs2(&[0xff22, 0xd800]));
             let err = data.to_string(py).unwrap_err();
-            assert!(err.get_type(py).is(&py.get_type::<PyUnicodeDecodeError>()));
+            assert!(err.get_type(py).is(py.get_type::<PyUnicodeDecodeError>()));
             assert!(err
                 .to_string()
                 .contains("'utf-16' codec can't decode bytes in position 0-3"));
@@ -728,7 +728,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+    #[cfg(not(any(Py_LIMITED_API, PyPy, GraalPy)))]
     fn test_string_data_ucs4() {
         Python::with_gil(|py| {
             let s = "哈哈🐈";
@@ -741,7 +741,7 @@ mod tests {
     }
 
     #[test]
-    #[cfg(all(not(any(Py_LIMITED_API, PyPy)), target_endian = "little"))]
+    #[cfg(all(not(any(Py_LIMITED_API, PyPy, GraalPy)), target_endian = "little"))]
     fn test_string_data_ucs4_invalid() {
         Python::with_gil(|py| {
             // U+20000 (valid) & U+d800 (never valid)
@@ -758,7 +758,7 @@ mod tests {
             let data = unsafe { s.data().unwrap() };
             assert_eq!(data, PyStringData::Ucs4(&[0x20000, 0xd800]));
             let err = data.to_string(py).unwrap_err();
-            assert!(err.get_type(py).is(&py.get_type::<PyUnicodeDecodeError>()));
+            assert!(err.get_type(py).is(py.get_type::<PyUnicodeDecodeError>()));
             assert!(err
                 .to_string()
                 .contains("'utf-32' codec can't decode bytes in position 0-7"));
diff --git a/src/types/typeobject.rs b/src/types/typeobject.rs
index 194755fc5a3..2efe26bff49 100644
--- a/src/types/typeobject.rs
+++ b/src/types/typeobject.rs
@@ -165,7 +165,7 @@ impl<'py> PyTypeMethods<'py> for Bound<'py, PyType> {
             if module_str == "builtins" || module_str == "__main__" {
                 qualname.downcast_into()?
             } else {
-                PyString::new(self.py(), &format!("{}.{}", module, qualname))
+                PyString::new(self.py(), &format!("{module}.{qualname}"))
             }
         };
 
diff --git a/src/types/weakref/proxy.rs b/src/types/weakref/proxy.rs
index c16162361fb..f60321fdd3d 100644
--- a/src/types/weakref/proxy.rs
+++ b/src/types/weakref/proxy.rs
@@ -265,7 +265,7 @@ mod tests {
                     #[cfg(not(Py_LIMITED_API))]
                     assert_eq!(
                         reference.get_type().to_string(),
-                        format!("<class {}>", CLASS_NAME)
+                        format!("<class {CLASS_NAME}>")
                     );
 
                     assert_eq!(reference.getattr("__class__")?.to_string(), "<class 'A'>");
@@ -282,7 +282,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
@@ -306,7 +306,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
@@ -440,7 +440,7 @@ mod tests {
                     #[cfg(not(Py_LIMITED_API))]
                     assert_eq!(
                         reference.get_type().to_string(),
-                        format!("<class {}>", CLASS_NAME)
+                        format!("<class {CLASS_NAME}>")
                     );
 
                     assert_eq!(
@@ -460,7 +460,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
@@ -484,7 +484,7 @@ mod tests {
                         #[cfg(not(Py_LIMITED_API))]
                         let result = result
                             & (err.value(py).to_string()
-                                == format!("{} object is not callable", CLASS_NAME));
+                                == format!("{CLASS_NAME} object is not callable"));
                         result
                     }));
 
diff --git a/src/types/weakref/reference.rs b/src/types/weakref/reference.rs
index fb63af4cc70..a4540f7eaf9 100644
--- a/src/types/weakref/reference.rs
+++ b/src/types/weakref/reference.rs
@@ -22,6 +22,7 @@ pyobject_subclassable_native_type!(PyWeakrefReference, crate::ffi::PyWeakReferen
 pyobject_native_type!(
     PyWeakrefReference,
     ffi::PyWeakReference,
+    // TODO: should not be depending on a private symbol here!
     pyobject_native_static_type_object!(ffi::_PyWeakref_RefType),
     #module=Some("weakref"),
     #checkfunction=ffi::PyWeakref_CheckRefExact
diff --git a/tests/test_append_to_inittab.rs b/tests/test_append_to_inittab.rs
index fdf14a2aea9..3c042bd2bb2 100644
--- a/tests/test_append_to_inittab.rs
+++ b/tests/test_append_to_inittab.rs
@@ -19,7 +19,7 @@ mod module_mod_with_functions {
     use super::foo;
 }
 
-#[cfg(not(PyPy))]
+#[cfg(not(any(PyPy, GraalPy)))]
 #[test]
 fn test_module_append_to_inittab() {
     use pyo3::{append_to_inittab, ffi};
diff --git a/tests/test_arithmetics.rs b/tests/test_arithmetics.rs
index 21e32d4c13c..2e5220eadd8 100644
--- a/tests/test_arithmetics.rs
+++ b/tests/test_arithmetics.rs
@@ -182,59 +182,59 @@ impl BinaryArithmetic {
     }
 
     fn __add__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA + {:?}", rhs)
+        format!("BA + {rhs:?}")
     }
 
     fn __sub__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA - {:?}", rhs)
+        format!("BA - {rhs:?}")
     }
 
     fn __mul__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA * {:?}", rhs)
+        format!("BA * {rhs:?}")
     }
 
     fn __matmul__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA @ {:?}", rhs)
+        format!("BA @ {rhs:?}")
     }
 
     fn __truediv__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA / {:?}", rhs)
+        format!("BA / {rhs:?}")
     }
 
     fn __floordiv__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA // {:?}", rhs)
+        format!("BA // {rhs:?}")
     }
 
     fn __mod__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA % {:?}", rhs)
+        format!("BA % {rhs:?}")
     }
 
     fn __divmod__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("divmod(BA, {:?})", rhs)
+        format!("divmod(BA, {rhs:?})")
     }
 
     fn __lshift__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA << {:?}", rhs)
+        format!("BA << {rhs:?}")
     }
 
     fn __rshift__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA >> {:?}", rhs)
+        format!("BA >> {rhs:?}")
     }
 
     fn __and__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA & {:?}", rhs)
+        format!("BA & {rhs:?}")
     }
 
     fn __xor__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA ^ {:?}", rhs)
+        format!("BA ^ {rhs:?}")
     }
 
     fn __or__(&self, rhs: &Bound<'_, PyAny>) -> String {
-        format!("BA | {:?}", rhs)
+        format!("BA | {rhs:?}")
     }
 
     fn __pow__(&self, rhs: &Bound<'_, PyAny>, mod_: Option<u32>) -> String {
-        format!("BA ** {:?} (mod: {:?})", rhs, mod_)
+        format!("BA ** {rhs:?} (mod: {mod_:?})")
     }
 }
 
@@ -303,39 +303,39 @@ struct RhsArithmetic {}
 #[pymethods]
 impl RhsArithmetic {
     fn __radd__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} + RA", other)
+        format!("{other:?} + RA")
     }
 
     fn __rsub__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} - RA", other)
+        format!("{other:?} - RA")
     }
 
     fn __rmul__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} * RA", other)
+        format!("{other:?} * RA")
     }
 
     fn __rlshift__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} << RA", other)
+        format!("{other:?} << RA")
     }
 
     fn __rrshift__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} >> RA", other)
+        format!("{other:?} >> RA")
     }
 
     fn __rand__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} & RA", other)
+        format!("{other:?} & RA")
     }
 
     fn __rxor__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} ^ RA", other)
+        format!("{other:?} ^ RA")
     }
 
     fn __ror__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} | RA", other)
+        format!("{other:?} | RA")
     }
 
     fn __rpow__(&self, other: &Bound<'_, PyAny>, _mod: Option<&Bound<'_, PyAny>>) -> String {
-        format!("{:?} ** RA", other)
+        format!("{other:?} ** RA")
     }
 }
 
@@ -380,91 +380,91 @@ impl LhsAndRhs {
     // }
 
     fn __add__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} + {:?}", lhs, rhs)
+        format!("{lhs:?} + {rhs:?}")
     }
 
     fn __sub__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} - {:?}", lhs, rhs)
+        format!("{lhs:?} - {rhs:?}")
     }
 
     fn __mul__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} * {:?}", lhs, rhs)
+        format!("{lhs:?} * {rhs:?}")
     }
 
     fn __lshift__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} << {:?}", lhs, rhs)
+        format!("{lhs:?} << {rhs:?}")
     }
 
     fn __rshift__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} >> {:?}", lhs, rhs)
+        format!("{lhs:?} >> {rhs:?}")
     }
 
     fn __and__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} & {:?}", lhs, rhs)
+        format!("{lhs:?} & {rhs:?}")
     }
 
     fn __xor__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} ^ {:?}", lhs, rhs)
+        format!("{lhs:?} ^ {rhs:?}")
     }
 
     fn __or__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} | {:?}", lhs, rhs)
+        format!("{lhs:?} | {rhs:?}")
     }
 
     fn __pow__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>, _mod: Option<usize>) -> String {
-        format!("{:?} ** {:?}", lhs, rhs)
+        format!("{lhs:?} ** {rhs:?}")
     }
 
     fn __matmul__(lhs: PyRef<'_, Self>, rhs: &Bound<'_, PyAny>) -> String {
-        format!("{:?} @ {:?}", lhs, rhs)
+        format!("{lhs:?} @ {rhs:?}")
     }
 
     fn __radd__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} + RA", other)
+        format!("{other:?} + RA")
     }
 
     fn __rsub__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} - RA", other)
+        format!("{other:?} - RA")
     }
 
     fn __rmul__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} * RA", other)
+        format!("{other:?} * RA")
     }
 
     fn __rlshift__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} << RA", other)
+        format!("{other:?} << RA")
     }
 
     fn __rrshift__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} >> RA", other)
+        format!("{other:?} >> RA")
     }
 
     fn __rand__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} & RA", other)
+        format!("{other:?} & RA")
     }
 
     fn __rxor__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} ^ RA", other)
+        format!("{other:?} ^ RA")
     }
 
     fn __ror__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} | RA", other)
+        format!("{other:?} | RA")
     }
 
     fn __rpow__(&self, other: &Bound<'_, PyAny>, _mod: Option<&Bound<'_, PyAny>>) -> String {
-        format!("{:?} ** RA", other)
+        format!("{other:?} ** RA")
     }
 
     fn __rmatmul__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} @ RA", other)
+        format!("{other:?} @ RA")
     }
 
     fn __rtruediv__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} / RA", other)
+        format!("{other:?} / RA")
     }
 
     fn __rfloordiv__(&self, other: &Bound<'_, PyAny>) -> String {
-        format!("{:?} // RA", other)
+        format!("{other:?} // RA")
     }
 }
 
@@ -677,10 +677,7 @@ mod return_not_implemented {
             py_run!(
                 py,
                 c2,
-                &format!(
-                    "class Other: pass\nassert c2.__{}__(Other()) is NotImplemented",
-                    dunder
-                )
+                &format!("class Other: pass\nassert c2.__{dunder}__(Other()) is NotImplemented")
             );
         });
     }
diff --git a/tests/test_class_attributes.rs b/tests/test_class_attributes.rs
index 3f8eb74df5f..5c4398e7a56 100644
--- a/tests/test_class_attributes.rs
+++ b/tests/test_class_attributes.rs
@@ -1,6 +1,7 @@
 #![cfg(feature = "macros")]
 
 use pyo3::prelude::*;
+use pyo3::py_run;
 
 #[path = "../src/tests/common.rs"]
 mod common;
@@ -66,14 +67,68 @@ fn class_attributes() {
     });
 }
 
-// Ignored because heap types are not immutable:
-// https://github.com/python/cpython/blob/master/Objects/typeobject.c#L3399-L3409
 #[test]
-#[ignore]
-fn class_attributes_are_immutable() {
+fn class_attributes_mutable() {
+    #[pyclass]
+    struct Foo {}
+
+    #[pymethods]
+    impl Foo {
+        #[classattr]
+        const MY_CONST: &'static str = "foobar";
+
+        #[classattr]
+        fn a() -> i32 {
+            5
+        }
+    }
+
     Python::with_gil(|py| {
-        let foo_obj = py.get_type::<Foo>();
-        py_expect_exception!(py, foo_obj, "foo_obj.a = 6", PyTypeError);
+        let obj = py.get_type::<Foo>();
+        py_run!(py, obj, "obj.MY_CONST = 'BAZ'");
+        py_run!(py, obj, "obj.a = 42");
+        py_assert!(py, obj, "obj.MY_CONST == 'BAZ'");
+        py_assert!(py, obj, "obj.a == 42");
+    });
+}
+
+#[test]
+#[cfg(any(Py_3_14, all(Py_3_10, not(Py_LIMITED_API))))]
+fn immutable_type_object() {
+    #[pyclass(immutable_type)]
+    struct ImmutableType {}
+
+    #[pymethods]
+    impl ImmutableType {
+        #[classattr]
+        const MY_CONST: &'static str = "foobar";
+
+        #[classattr]
+        fn a() -> i32 {
+            5
+        }
+    }
+
+    #[pyclass(immutable_type)]
+    enum SimpleImmutable {
+        Variant = 42,
+    }
+
+    #[pyclass(immutable_type)]
+    enum ComplexImmutable {
+        Variant(u32),
+    }
+
+    Python::with_gil(|py| {
+        let obj = py.get_type::<ImmutableType>();
+        py_expect_exception!(py, obj, "obj.MY_CONST = 'FOOBAR'", PyTypeError);
+        py_expect_exception!(py, obj, "obj.a = 6", PyTypeError);
+
+        let obj = py.get_type::<SimpleImmutable>();
+        py_expect_exception!(py, obj, "obj.Variant = 0", PyTypeError);
+
+        let obj = py.get_type::<ComplexImmutable>();
+        py_expect_exception!(py, obj, "obj.Variant = 0", PyTypeError);
     });
 }
 
diff --git a/tests/test_class_basics.rs b/tests/test_class_basics.rs
index 3cca37c3bd9..1c579b7307a 100644
--- a/tests/test_class_basics.rs
+++ b/tests/test_class_basics.rs
@@ -714,3 +714,34 @@ fn test_unsendable_dict_with_weakref() {
         );
     });
 }
+
+#[cfg(Py_3_9)]
+#[pyclass(generic)]
+struct ClassWithRuntimeParametrization {
+    #[pyo3(get, set)]
+    value: PyObject,
+}
+
+#[cfg(Py_3_9)]
+#[pymethods]
+impl ClassWithRuntimeParametrization {
+    #[new]
+    fn new(value: PyObject) -> ClassWithRuntimeParametrization {
+        Self { value }
+    }
+}
+
+#[test]
+#[cfg(Py_3_9)]
+fn test_runtime_parametrization() {
+    Python::with_gil(|py| {
+        let ty = py.get_type::<ClassWithRuntimeParametrization>();
+        py_assert!(py, ty, "ty[int] == ty.__class_getitem__((int,))");
+        py_run!(
+            py,
+            ty,
+            "import types;
+            assert ty.__class_getitem__((int,)) == types.GenericAlias(ty, (int,))"
+        );
+    });
+}
diff --git a/tests/test_class_formatting.rs b/tests/test_class_formatting.rs
index 10f760b9c4a..353f2abf7ed 100644
--- a/tests/test_class_formatting.rs
+++ b/tests/test_class_formatting.rs
@@ -16,7 +16,7 @@ pub enum MyEnum2 {
 
 impl Display for MyEnum2 {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
@@ -34,7 +34,7 @@ impl Display for MyEnum3 {
             MyEnum3::Variant => "AwesomeVariant",
             MyEnum3::OtherVariant => "OtherVariant",
         };
-        write!(f, "MyEnum.{}", variant)
+        write!(f, "MyEnum.{variant}")
     }
 }
 
@@ -97,7 +97,7 @@ enum ComplexEnumWithStr {
 
 impl Display for ComplexEnumWithStr {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
diff --git a/tests/test_compile_error.rs b/tests/test_compile_error.rs
index 958c5ff253d..c6990430366 100644
--- a/tests/test_compile_error.rs
+++ b/tests/test_compile_error.rs
@@ -10,6 +10,10 @@ fn test_compile_errors() {
     t.compile_fail("tests/ui/invalid_pyclass_args.rs");
     t.compile_fail("tests/ui/invalid_pyclass_enum.rs");
     t.compile_fail("tests/ui/invalid_pyclass_item.rs");
+    #[cfg(Py_3_9)]
+    t.compile_fail("tests/ui/invalid_pyclass_generic.rs");
+    #[cfg(Py_3_9)]
+    t.compile_fail("tests/ui/pyclass_generic_enum.rs");
     t.compile_fail("tests/ui/invalid_pyfunction_signatures.rs");
     t.compile_fail("tests/ui/invalid_pyfunction_definition.rs");
     #[cfg(any(not(Py_LIMITED_API), Py_3_11))]
@@ -33,7 +37,6 @@ fn test_compile_errors() {
     t.compile_fail("tests/ui/wrong_aspyref_lifetimes.rs");
     #[cfg(not(any(feature = "uuid")))]
     t.compile_fail("tests/ui/invalid_pyfunctions.rs");
-    #[cfg(not(any(feature = "hashbrown", feature = "indexmap")))]
     t.compile_fail("tests/ui/invalid_pymethods.rs");
     // output changes with async feature
     #[cfg(all(Py_LIMITED_API, feature = "experimental-async"))]
@@ -71,7 +74,8 @@ fn test_compile_errors() {
     t.compile_fail("tests/ui/duplicate_pymodule_submodule.rs");
     #[cfg(all(not(Py_LIMITED_API), Py_3_11))]
     t.compile_fail("tests/ui/invalid_base_class.rs");
+    #[cfg(any(not(Py_3_10), all(not(Py_3_14), Py_LIMITED_API)))]
+    t.compile_fail("tests/ui/immutable_type.rs");
     t.pass("tests/ui/ambiguous_associated_items.rs");
     t.pass("tests/ui/pyclass_probe.rs");
-    t.compile_fail("tests/ui/deprecated.rs");
 }
diff --git a/tests/test_coroutine.rs b/tests/test_coroutine.rs
index 89ab3d64a4b..6c9c17bd69c 100644
--- a/tests/test_coroutine.rs
+++ b/tests/test_coroutine.rs
@@ -9,7 +9,7 @@ use pyo3::{
     coroutine::CancelHandle,
     prelude::*,
     py_run,
-    types::{IntoPyDict, PyType},
+    types::{IntoPyDict, PyDict, PyType},
 };
 #[cfg(target_has_atomic = "64")]
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -32,10 +32,10 @@ fn noop_coroutine() {
     async fn noop() -> usize {
         42
     }
-    Python::with_gil(|gil| {
-        let noop = wrap_pyfunction!(noop, gil).unwrap();
+    Python::with_gil(|py| {
+        let noop = wrap_pyfunction!(noop, py).unwrap();
         let test = "import asyncio; assert asyncio.run(noop()) == 42";
-        py_run!(gil, noop, &handle_windows(test));
+        py_run!(py, noop, &handle_windows(test));
     })
 }
 
@@ -58,7 +58,7 @@ fn test_coroutine_qualname() {
         #[staticmethod]
         async fn my_staticmethod() {}
     }
-    Python::with_gil(|gil| {
+    Python::with_gil(|py| {
         let test = r#"
         for coro, name, qualname in [
             (my_fn(), "my_fn", "my_fn"),
@@ -69,12 +69,12 @@ fn test_coroutine_qualname() {
             assert coro.__name__ == name and coro.__qualname__ == qualname
         "#;
         let locals = [
-            ("my_fn", wrap_pyfunction!(my_fn, gil).unwrap().as_any()),
-            ("MyClass", gil.get_type::<MyClass>().as_any()),
+            ("my_fn", wrap_pyfunction!(my_fn, py).unwrap().as_any()),
+            ("MyClass", py.get_type::<MyClass>().as_any()),
         ]
-        .into_py_dict(gil)
+        .into_py_dict(py)
         .unwrap();
-        py_run!(gil, *locals, &handle_windows(test));
+        py_run!(py, *locals, &handle_windows(test));
     })
 }
 
@@ -93,10 +93,10 @@ fn sleep_0_like_coroutine() {
         })
         .await
     }
-    Python::with_gil(|gil| {
-        let sleep_0 = wrap_pyfunction!(sleep_0, gil).unwrap();
+    Python::with_gil(|py| {
+        let sleep_0 = wrap_pyfunction!(sleep_0, py).unwrap();
         let test = "import asyncio; assert asyncio.run(sleep_0()) == 42";
-        py_run!(gil, sleep_0, &handle_windows(test));
+        py_run!(py, sleep_0, &handle_windows(test));
     })
 }
 
@@ -112,10 +112,10 @@ async fn sleep(seconds: f64) -> usize {
 
 #[test]
 fn sleep_coroutine() {
-    Python::with_gil(|gil| {
-        let sleep = wrap_pyfunction!(sleep, gil).unwrap();
+    Python::with_gil(|py| {
+        let sleep = wrap_pyfunction!(sleep, py).unwrap();
         let test = r#"import asyncio; assert asyncio.run(sleep(0.1)) == 42"#;
-        py_run!(gil, sleep, &handle_windows(test));
+        py_run!(py, sleep, &handle_windows(test));
     })
 }
 
@@ -126,17 +126,17 @@ async fn return_tuple() -> (usize, usize) {
 
 #[test]
 fn tuple_coroutine() {
-    Python::with_gil(|gil| {
-        let func = wrap_pyfunction!(return_tuple, gil).unwrap();
+    Python::with_gil(|py| {
+        let func = wrap_pyfunction!(return_tuple, py).unwrap();
         let test = r#"import asyncio; assert asyncio.run(func()) == (42, 43)"#;
-        py_run!(gil, func, &handle_windows(test));
+        py_run!(py, func, &handle_windows(test));
     })
 }
 
 #[test]
 fn cancelled_coroutine() {
-    Python::with_gil(|gil| {
-        let sleep = wrap_pyfunction!(sleep, gil).unwrap();
+    Python::with_gil(|py| {
+        let sleep = wrap_pyfunction!(sleep, py).unwrap();
         let test = r#"
         import asyncio
         async def main():
@@ -146,9 +146,9 @@ fn cancelled_coroutine() {
             await task
         asyncio.run(main())
         "#;
-        let globals = gil.import("__main__").unwrap().dict();
+        let globals = PyDict::new(py);
         globals.set_item("sleep", sleep).unwrap();
-        let err = gil
+        let err = py
             .run(
                 &CString::new(pyo3::unindent::unindent(&handle_windows(test))).unwrap(),
                 Some(&globals),
@@ -156,7 +156,7 @@ fn cancelled_coroutine() {
             )
             .unwrap_err();
         assert_eq!(
-            err.value(gil).get_type().qualname().unwrap(),
+            err.value(py).get_type().qualname().unwrap(),
             "CancelledError"
         );
     })
@@ -174,8 +174,8 @@ fn coroutine_cancel_handle() {
             _ = cancel.cancelled().fuse() => 0,
         }
     }
-    Python::with_gil(|gil| {
-        let cancellable_sleep = wrap_pyfunction!(cancellable_sleep, gil).unwrap();
+    Python::with_gil(|py| {
+        let cancellable_sleep = wrap_pyfunction!(cancellable_sleep, py).unwrap();
         let test = r#"
         import asyncio;
         async def main():
@@ -185,11 +185,11 @@ fn coroutine_cancel_handle() {
             return await task
         assert asyncio.run(main()) == 0
         "#;
-        let globals = gil.import("__main__").unwrap().dict();
+        let globals = PyDict::new(py);
         globals
             .set_item("cancellable_sleep", cancellable_sleep)
             .unwrap();
-        gil.run(
+        py.run(
             &CString::new(pyo3::unindent::unindent(&handle_windows(test))).unwrap(),
             Some(&globals),
             None,
@@ -206,8 +206,8 @@ fn coroutine_is_cancelled() {
             sleep(0.001).await;
         }
     }
-    Python::with_gil(|gil| {
-        let sleep_loop = wrap_pyfunction!(sleep_loop, gil).unwrap();
+    Python::with_gil(|py| {
+        let sleep_loop = wrap_pyfunction!(sleep_loop, py).unwrap();
         let test = r#"
         import asyncio;
         async def main():
@@ -217,9 +217,9 @@ fn coroutine_is_cancelled() {
             await task
         asyncio.run(main())
         "#;
-        let globals = gil.import("__main__").unwrap().dict();
+        let globals = PyDict::new(py);
         globals.set_item("sleep_loop", sleep_loop).unwrap();
-        gil.run(
+        py.run(
             &CString::new(pyo3::unindent::unindent(&handle_windows(test))).unwrap(),
             Some(&globals),
             None,
@@ -234,8 +234,8 @@ fn coroutine_panic() {
     async fn panic() {
         panic!("test panic");
     }
-    Python::with_gil(|gil| {
-        let panic = wrap_pyfunction!(panic, gil).unwrap();
+    Python::with_gil(|py| {
+        let panic = wrap_pyfunction!(panic, py).unwrap();
         let test = r#"
         import asyncio
         coro = panic()
@@ -253,7 +253,7 @@ fn coroutine_panic() {
         else:
             assert False;
         "#;
-        py_run!(gil, panic, &handle_windows(test));
+        py_run!(py, panic, &handle_windows(test));
     })
 }
 
@@ -284,7 +284,7 @@ fn test_async_method_receiver() {
         }
     }
 
-    Python::with_gil(|gil| {
+    Python::with_gil(|py| {
         let test = r#"
         import asyncio
 
@@ -314,10 +314,10 @@ fn test_async_method_receiver() {
             assert False
         assert asyncio.run(coro3) == 1
         "#;
-        let locals = [("Counter", gil.get_type::<Counter>())]
-            .into_py_dict(gil)
+        let locals = [("Counter", py.get_type::<Counter>())]
+            .into_py_dict(py)
             .unwrap();
-        py_run!(gil, *locals, test);
+        py_run!(py, *locals, test);
     });
 
     assert!(IS_DROPPED.load(Ordering::SeqCst));
@@ -342,7 +342,7 @@ fn test_async_method_receiver_with_other_args() {
         }
     }
 
-    Python::with_gil(|gil| {
+    Python::with_gil(|py| {
         let test = r#"
         import asyncio
 
@@ -351,9 +351,9 @@ fn test_async_method_receiver_with_other_args() {
         assert asyncio.run(v.set_value(10)) == 10
         assert asyncio.run(v.get_value_plus_with(1, 1)) == 12
         "#;
-        let locals = [("Value", gil.get_type::<Value>())]
-            .into_py_dict(gil)
+        let locals = [("Value", py.get_type::<Value>())]
+            .into_py_dict(py)
             .unwrap();
-        py_run!(gil, *locals, test);
+        py_run!(py, *locals, test);
     });
 }
diff --git a/tests/test_datetime.rs b/tests/test_datetime.rs
index b1fad408dc5..55b4d1bfdfb 100644
--- a/tests/test_datetime.rs
+++ b/tests/test_datetime.rs
@@ -1,6 +1,6 @@
 #![cfg(not(Py_LIMITED_API))]
 
-use pyo3::types::{timezone_utc, IntoPyDict, PyDate, PyDateTime, PyTime};
+use pyo3::types::{IntoPyDict, PyDate, PyDateTime, PyTime, PyTzInfo};
 use pyo3::{ffi, prelude::*};
 use pyo3_ffi::PyDateTime_IMPORT;
 use std::ffi::CString;
@@ -17,7 +17,7 @@ fn _get_subclasses<'py>(
         .into_py_dict(py)
         .unwrap();
 
-    let make_subclass_py = CString::new(format!("class Subklass({}):\n    pass", py_type))?;
+    let make_subclass_py = CString::new(format!("class Subklass({py_type}):\n    pass"))?;
 
     let make_sub_subclass_py = ffi::c_str!("class SubSubklass(Subklass):\n    pass");
 
@@ -26,21 +26,21 @@ fn _get_subclasses<'py>(
 
     // Construct an instance of the base class
     let obj = py.eval(
-        &CString::new(format!("{}({})", py_type, args))?,
+        &CString::new(format!("{py_type}({args})"))?,
         None,
         Some(&locals),
     )?;
 
     // Construct an instance of the subclass
     let sub_obj = py.eval(
-        &CString::new(format!("Subklass({})", args))?,
+        &CString::new(format!("Subklass({args})"))?,
         None,
         Some(&locals),
     )?;
 
     // Construct an instance of the sub-subclass
     let sub_sub_obj = py.eval(
-        &CString::new(format!("SubSubklass({})", args))?,
+        &CString::new(format!("SubSubklass({args})"))?,
         None,
         Some(&locals),
     )?;
@@ -133,7 +133,7 @@ fn test_datetime_utc() {
     use pyo3::types::PyDateTime;
 
     Python::with_gil(|py| {
-        let utc = timezone_utc(py);
+        let utc = PyTzInfo::utc(py).unwrap();
 
         let dt = PyDateTime::new(py, 2018, 1, 1, 0, 0, 0, 0, Some(&utc)).unwrap();
 
diff --git a/tests/test_declarative_module.rs b/tests/test_declarative_module.rs
index 93e0e1366f0..c4c9cd1a31d 100644
--- a/tests/test_declarative_module.rs
+++ b/tests/test_declarative_module.rs
@@ -76,6 +76,20 @@ mod declarative_module {
     #[pymodule_export]
     use super::external_submodule;
 
+    #[pymodule_export]
+    const FOO: u32 = 42;
+
+    #[pymodule_export]
+    #[cfg(Py_LIMITED_API)]
+    const BAR: &str = "BAR";
+
+    #[pymodule_export]
+    #[allow(non_upper_case_globals)]
+    const r#type: char = '!';
+
+    #[allow(unused)]
+    const NOT_EXPORTED: &str = "not exported";
+
     #[pymodule]
     mod inner {
         use super::*;
@@ -190,7 +204,14 @@ fn test_declarative_module() {
         py_assert!(py, m, "hasattr(m, 'LocatedClass')");
         py_assert!(py, m, "isinstance(m.inner.Struct(), m.inner.Struct)");
         py_assert!(py, m, "isinstance(m.inner.Enum.A, m.inner.Enum)");
-        py_assert!(py, m, "hasattr(m, 'external_submodule')")
+        py_assert!(py, m, "hasattr(m, 'external_submodule')");
+        py_assert!(py, m, "m.FOO == 42");
+        #[cfg(Py_LIMITED_API)]
+        py_assert!(py, m, "m.BAR == 'BAR'");
+        #[cfg(not(Py_LIMITED_API))]
+        py_assert!(py, m, "not hasattr(m, 'BAR')");
+        py_assert!(py, m, "m.type == '!'");
+        py_assert!(py, m, "not hasattr(m, 'NOT_EXPORTED')");
     })
 }
 
diff --git a/tests/test_frompy_intopy_roundtrip.rs b/tests/test_frompy_intopy_roundtrip.rs
index b17320fa43b..58d4053e472 100644
--- a/tests/test_frompy_intopy_roundtrip.rs
+++ b/tests/test_frompy_intopy_roundtrip.rs
@@ -1,7 +1,7 @@
 #![cfg(feature = "macros")]
 
 use pyo3::types::{PyDict, PyString};
-use pyo3::{prelude::*, IntoPyObject, IntoPyObjectRef};
+use pyo3::{prelude::*, IntoPyObject, IntoPyObjectExt, IntoPyObjectRef};
 use std::collections::HashMap;
 use std::hash::Hash;
 
@@ -196,12 +196,28 @@ fn test_transparent_tuple_struct() {
     });
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct IntWrapper(u32);
+
+fn int_wrapper_into_py<'py>(
+    v: std::borrow::Cow<'_, IntWrapper>,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyAny>> {
+    v.0.into_bound_py_any(py)
+}
+
+fn int_wrapper_from_py(v: &Bound<'_, PyAny>) -> PyResult<IntWrapper> {
+    v.extract().map(IntWrapper)
+}
+
 #[derive(Debug, Clone, PartialEq, IntoPyObject, IntoPyObjectRef, FromPyObject)]
 pub enum Foo {
     TupleVar(usize, String),
     StructVar {
         #[pyo3(item)]
         test: char,
+        #[pyo3(item, into_py_with=int_wrapper_into_py, from_py_with=int_wrapper_from_py)]
+        int: IntWrapper,
     },
     #[pyo3(transparent)]
     TransparentTuple(usize),
@@ -209,6 +225,11 @@ pub enum Foo {
     TransparentStructVar {
         a: Option<String>,
     },
+    #[pyo3(rename_all = "camelCase", from_item_all)]
+    RenameAll {
+        long_field_name: [u16; 2],
+        other_field: Option<String>,
+    },
 }
 
 #[test]
@@ -221,7 +242,10 @@ fn test_enum() {
         let foo = tuple_var.clone().into_pyobject(py).unwrap();
         assert_eq!(tuple_var, foo.extract::<Foo>().unwrap());
 
-        let struct_var = Foo::StructVar { test: 'b' };
+        let struct_var = Foo::StructVar {
+            test: 'b',
+            int: IntWrapper(42),
+        };
         let foo = (&struct_var)
             .into_pyobject(py)
             .unwrap()
@@ -251,5 +275,15 @@ fn test_enum() {
 
         let foo = transparent_struct_var.clone().into_pyobject(py).unwrap();
         assert_eq!(transparent_struct_var, foo.extract::<Foo>().unwrap());
+
+        let rename_all_struct_var = Foo::RenameAll {
+            long_field_name: [1, 2],
+            other_field: None,
+        };
+        let foo = (&rename_all_struct_var).into_pyobject(py).unwrap();
+        assert_eq!(rename_all_struct_var, foo.extract::<Foo>().unwrap());
+
+        let foo = rename_all_struct_var.clone().into_pyobject(py).unwrap();
+        assert_eq!(rename_all_struct_var, foo.extract::<Foo>().unwrap());
     });
 }
diff --git a/tests/test_frompyobject.rs b/tests/test_frompyobject.rs
index f1a68c18f01..7e5110d7e5a 100644
--- a/tests/test_frompyobject.rs
+++ b/tests/test_frompyobject.rs
@@ -467,7 +467,7 @@ fn test_enum() {
                 assert_eq!(test, 1);
                 assert_eq!(test2, "test");
             }
-            _ => panic!("Expected extracting Foo::TupleVar, got {:?}", f),
+            _ => panic!("Expected extracting Foo::TupleVar, got {f:?}"),
         }
 
         let pye = PyE {
@@ -481,7 +481,7 @@ fn test_enum() {
             .expect("Failed to extract Foo from PyE");
         match f {
             Foo::StructVar { test } => assert_eq!(test.to_string_lossy(), "foo"),
-            _ => panic!("Expected extracting Foo::StructVar, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructVar, got {f:?}"),
         }
 
         let int = 1i32.into_pyobject(py).unwrap();
@@ -490,7 +490,7 @@ fn test_enum() {
             .expect("Failed to extract Foo from int");
         match f {
             Foo::TransparentTuple(test) => assert_eq!(test, 1),
-            _ => panic!("Expected extracting Foo::TransparentTuple, got {:?}", f),
+            _ => panic!("Expected extracting Foo::TransparentTuple, got {f:?}"),
         }
         let none = py.None();
         let f = none
@@ -498,7 +498,7 @@ fn test_enum() {
             .expect("Failed to extract Foo from int");
         match f {
             Foo::TransparentStructVar { a } => assert!(a.is_none()),
-            _ => panic!("Expected extracting Foo::TransparentStructVar, got {:?}", f),
+            _ => panic!("Expected extracting Foo::TransparentStructVar, got {f:?}"),
         }
 
         let pybool = PyBool { bla: true }.into_pyobject(py).unwrap();
@@ -507,7 +507,7 @@ fn test_enum() {
             .expect("Failed to extract Foo from PyBool");
         match f {
             Foo::StructVarGetAttrArg { a } => assert!(a),
-            _ => panic!("Expected extracting Foo::StructVarGetAttrArg, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructVarGetAttrArg, got {f:?}"),
         }
 
         let dict = PyDict::new(py);
@@ -517,7 +517,7 @@ fn test_enum() {
             .expect("Failed to extract Foo from dict");
         match f {
             Foo::StructWithGetItem { a } => assert_eq!(a, "test"),
-            _ => panic!("Expected extracting Foo::StructWithGetItem, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructWithGetItem, got {f:?}"),
         }
 
         let dict = PyDict::new(py);
@@ -527,7 +527,7 @@ fn test_enum() {
             .expect("Failed to extract Foo from dict");
         match f {
             Foo::StructWithGetItemArg { a } => assert_eq!(a, "test"),
-            _ => panic!("Expected extracting Foo::StructWithGetItemArg, got {:?}", f),
+            _ => panic!("Expected extracting Foo::StructWithGetItemArg, got {f:?}"),
         }
     });
 }
@@ -588,10 +588,7 @@ fn test_enum_catch_all() {
                 let d = any.extract::<Bound<'_, PyDict>>().expect("Expected pydict");
                 assert!(d.is_empty());
             }
-            _ => panic!(
-                "Expected extracting EnumWithCatchAll::CatchAll, got {:?}",
-                f
-            ),
+            _ => panic!("Expected extracting EnumWithCatchAll::CatchAll, got {f:?}"),
         }
     });
 }
diff --git a/tests/test_inheritance.rs b/tests/test_inheritance.rs
index 7190dd49555..bc2e7e24890 100644
--- a/tests/test_inheritance.rs
+++ b/tests/test_inheritance.rs
@@ -182,12 +182,11 @@ mod inheriting_native_type {
     use pyo3::exceptions::PyException;
     use pyo3::types::PyDict;
 
-    #[cfg(not(PyPy))]
+    #[cfg(not(any(PyPy, GraalPy)))]
     #[test]
     fn inherit_set() {
         use pyo3::types::PySet;
 
-        #[cfg(not(PyPy))]
         #[pyclass(extends=PySet)]
         #[derive(Debug)]
         struct SetWithName {
@@ -195,7 +194,6 @@ mod inheriting_native_type {
             _name: &'static str,
         }
 
-        #[cfg(not(PyPy))]
         #[pymethods]
         impl SetWithName {
             #[new]
diff --git a/tests/test_intopyobject.rs b/tests/test_intopyobject.rs
index 8e758c636cd..2fbddddb8c1 100644
--- a/tests/test_intopyobject.rs
+++ b/tests/test_intopyobject.rs
@@ -252,3 +252,38 @@ fn test_into_py_with() {
         );
     });
 }
+
+#[test]
+fn test_struct_into_py_rename_all() {
+    #[derive(IntoPyObject, IntoPyObjectRef)]
+    #[pyo3(rename_all = "camelCase")]
+    struct Foo {
+        foo_bar: String,
+        #[pyo3(item("BAZ"))]
+        baz: usize,
+        #[pyo3(item)]
+        long_field_name: f32,
+    }
+
+    let foo = Foo {
+        foo_bar: "foobar".into(),
+        baz: 42,
+        long_field_name: 0.0,
+    };
+
+    Python::with_gil(|py| {
+        let py_foo_ref = (&foo).into_pyobject(py).unwrap();
+        let py_foo = foo.into_pyobject(py).unwrap();
+
+        py_run!(
+            py,
+            py_foo_ref,
+            "assert py_foo_ref == {'fooBar': 'foobar', 'BAZ': 42, 'longFieldName': 0},f'{py_foo_ref}'"
+        );
+        py_run!(
+            py,
+            py_foo,
+            "assert py_foo == {'fooBar': 'foobar', 'BAZ': 42, 'longFieldName': 0},f'{py_foo}'"
+        );
+    });
+}
diff --git a/tests/test_methods.rs b/tests/test_methods.rs
index 9a7f593df2a..d6ce5e30aae 100644
--- a/tests/test_methods.rs
+++ b/tests/test_methods.rs
@@ -166,7 +166,7 @@ struct StaticMethodWithArgs {}
 impl StaticMethodWithArgs {
     #[staticmethod]
     fn method(_py: Python<'_>, input: i32) -> String {
-        format!("0x{:x}", input)
+        format!("0x{input:x}")
     }
 }
 
@@ -898,7 +898,7 @@ impl FromSequence {
     fn new(seq: Option<&Bound<'_, PySequence>>) -> PyResult<Self> {
         if let Some(seq) = seq {
             Ok(FromSequence {
-                numbers: seq.as_ref().extract::<Vec<_>>()?,
+                numbers: seq.as_any().extract::<Vec<_>>()?,
             })
         } else {
             Ok(FromSequence::default())
diff --git a/tests/test_proto_methods.rs b/tests/test_proto_methods.rs
index 23f7f6cf213..56039502f24 100644
--- a/tests/test_proto_methods.rs
+++ b/tests/test_proto_methods.rs
@@ -853,7 +853,7 @@ impl DefaultedContains {
     fn __iter__(&self, py: Python<'_>) -> PyObject {
         PyList::new(py, ["a", "b", "c"])
             .unwrap()
-            .as_ref()
+            .as_any()
             .try_iter()
             .unwrap()
             .into()
@@ -868,7 +868,7 @@ impl NoContains {
     fn __iter__(&self, py: Python<'_>) -> PyObject {
         PyList::new(py, ["a", "b", "c"])
             .unwrap()
-            .as_ref()
+            .as_any()
             .try_iter()
             .unwrap()
             .into()
diff --git a/tests/test_pyerr_debug_unformattable.rs b/tests/test_pyerr_debug_unformattable.rs
index 615868207b4..6c4755087c5 100644
--- a/tests/test_pyerr_debug_unformattable.rs
+++ b/tests/test_pyerr_debug_unformattable.rs
@@ -32,7 +32,7 @@ raise Exception('banana')"#
             )
             .expect_err("raising should have given us an error");
 
-        let debug_str = format!("{:?}", err);
+        let debug_str = format!("{err:?}");
         assert!(debug_str.starts_with("PyErr { "));
         assert!(debug_str.ends_with(" }"));
 
@@ -46,8 +46,7 @@ raise Exception('banana')"#
         let traceback = fields.next().unwrap();
         assert!(
             traceback.starts_with("traceback: Some(\"<unformattable <traceback object at 0x"),
-            "assertion failed, actual traceback str: {:?}",
-            traceback
+            "assertion failed, actual traceback str: {traceback:?}"
         );
         assert!(fields.next().is_none());
 
diff --git a/tests/test_pyfunction.rs b/tests/test_pyfunction.rs
index 77983653c89..3f57f66e976 100644
--- a/tests/test_pyfunction.rs
+++ b/tests/test_pyfunction.rs
@@ -30,7 +30,7 @@ fn test_rust_keyword_name() {
 
 #[pyfunction(signature = (arg = true))]
 fn optional_bool(arg: Option<bool>) -> String {
-    format!("{:?}", arg)
+    format!("{arg:?}")
 }
 
 #[test]
@@ -278,10 +278,7 @@ fn conversion_error(
     option_arg: Option<i64>,
     struct_arg: Option<ValueClass>,
 ) {
-    println!(
-        "{:?} {:?} {:?} {:?} {:?}",
-        str_arg, int_arg, tuple_arg, option_arg, struct_arg
-    );
+    println!("{str_arg:?} {int_arg:?} {tuple_arg:?} {option_arg:?} {struct_arg:?}");
 }
 
 #[test]
@@ -488,7 +485,7 @@ fn test_closure() {
                             s.push_str("-py");
                             Ok(s.into_pyobject(py)?.into_any().unbind())
                         } else {
-                            panic!("unexpected argument type for {:?}", elem)
+                            panic!("unexpected argument type for {elem:?}")
                         }
                     })
                     .collect();
diff --git a/tests/test_sequence.rs b/tests/test_sequence.rs
index e8f61e80e42..9405aa08487 100644
--- a/tests/test_sequence.rs
+++ b/tests/test_sequence.rs
@@ -255,15 +255,15 @@ fn test_inplace_repeat() {
 // Check that #[pyo3(get, set)] works correctly for Vec<PyObject>
 
 #[pyclass]
-struct GenericList {
+struct AnyObjectList {
     #[pyo3(get, set)]
     items: Vec<PyObject>,
 }
 
 #[test]
-fn test_generic_list_get() {
+fn test_any_object_list_get() {
     Python::with_gil(|py| {
-        let list = GenericList {
+        let list = AnyObjectList {
             items: [1i32, 2, 3]
                 .iter()
                 .map(|i| i.into_pyobject(py).unwrap().into_any().unbind())
@@ -277,9 +277,9 @@ fn test_generic_list_get() {
 }
 
 #[test]
-fn test_generic_list_set() {
+fn test_any_object_list_set() {
     Python::with_gil(|py| {
-        let list = Bound::new(py, GenericList { items: vec![] }).unwrap();
+        let list = Bound::new(py, AnyObjectList { items: vec![] }).unwrap();
 
         py_run!(py, list, "list.items = [1, 2, 3]");
         assert!(list
@@ -367,3 +367,60 @@ fn sequence_length() {
         unsafe { ffi::PyErr_Clear() };
     })
 }
+
+#[cfg(Py_3_10)]
+#[pyclass(generic, sequence)]
+struct GenericList {
+    #[pyo3(get, set)]
+    items: Vec<PyObject>,
+}
+
+#[cfg(Py_3_10)]
+#[pymethods]
+impl GenericList {
+    fn __len__(&self) -> usize {
+        self.items.len()
+    }
+
+    fn __getitem__(&self, idx: isize) -> PyResult<PyObject> {
+        match self.items.get(idx as usize) {
+            Some(x) => pyo3::Python::with_gil(|py| Ok(x.clone_ref(py))),
+            None => Err(PyIndexError::new_err("Index out of bounds")),
+        }
+    }
+}
+
+#[cfg(Py_3_10)]
+#[test]
+fn test_generic_both_subscriptions_types() {
+    use pyo3::types::PyInt;
+    use std::convert::Infallible;
+
+    Python::with_gil(|py| {
+        let l = Bound::new(
+            py,
+            GenericList {
+                items: [1, 2, 3]
+                    .iter()
+                    .map(|x| -> PyObject {
+                        let x: Result<Bound<'_, PyInt>, Infallible> = x.into_pyobject(py);
+                        x.unwrap().into_any().unbind()
+                    })
+                    .chain([py.None()])
+                    .collect(),
+            },
+        )
+        .unwrap();
+        let ty = py.get_type::<GenericList>();
+        py_assert!(py, l, "l[0] == 1");
+        py_run!(
+            py,
+            ty,
+            "import types;
+            import typing;
+            IntOrNone: typing.TypeAlias = typing.Union[int, None];
+            assert ty[IntOrNone] == types.GenericAlias(ty, (IntOrNone,))"
+        );
+        py_assert!(py, l, "list(reversed(l)) == [None, 3, 2, 1]");
+    });
+}
diff --git a/tests/test_super.rs b/tests/test_super.rs
index 4ff049824b0..5c17af3503d 100644
--- a/tests/test_super.rs
+++ b/tests/test_super.rs
@@ -1,4 +1,4 @@
-#![cfg(all(feature = "macros", not(PyPy)))]
+#![cfg(all(feature = "macros", not(any(PyPy, GraalPy))))]
 
 use pyo3::{prelude::*, types::PySuper};
 
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
deleted file mode 100644
index 8d5c73780cf..00000000000
--- a/tests/ui/deprecated.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#![deny(deprecated)]
-use pyo3::prelude::*;
-
-#[pyfunction]
-fn from_py_with_in_function(
-    #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] argument: usize,
-) -> usize {
-    argument
-}
-
-#[pyclass]
-struct Number(usize);
-
-#[pymethods]
-impl Number {
-    #[new]
-    fn from_py_with_in_method(
-        #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] value: usize,
-    ) -> Self {
-        Self(value)
-    }
-}
-
-#[derive(FromPyObject)]
-struct FromPyWithStruct {
-    #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")]
-    len: usize,
-    other: usize,
-}
-
-#[derive(FromPyObject)]
-struct FromPyWithTuple(
-    #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] usize,
-    usize,
-);
-
-fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
deleted file mode 100644
index 63664c3f77c..00000000000
--- a/tests/ui/deprecated.stderr
+++ /dev/null
@@ -1,33 +0,0 @@
-error: use of deprecated constant `__pyfunction_from_py_with_in_function::LIT_STR_DEPRECATION`: remove the quotes from the literal
-       = help: use `Bound :: < '_, PyAny > :: len` instead of `"Bound :: < '_, PyAny > :: len"`
- --> tests/ui/deprecated.rs:6:27
-  |
-6 |     #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] argument: usize,
-  |                           ^^^^^^^^^^^^^^^^^^^^^^^^^
-  |
-note: the lint level is defined here
- --> tests/ui/deprecated.rs:1:9
-  |
-1 | #![deny(deprecated)]
-  |         ^^^^^^^^^^
-
-error: use of deprecated constant `Number::__pymethod___new____::LIT_STR_DEPRECATION`: remove the quotes from the literal
-       = help: use `Bound :: < '_, PyAny > :: len` instead of `"Bound :: < '_, PyAny > :: len"`
-  --> tests/ui/deprecated.rs:18:31
-   |
-18 |         #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] value: usize,
-   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: use of deprecated constant `<FromPyWithStruct as pyo3::FromPyObject<'py>>::extract_bound::LIT_STR_DEPRECATION`: remove the quotes from the literal
-       = help: use `Bound :: < '_, PyAny > :: len` instead of `"Bound :: < '_, PyAny > :: len"`
-  --> tests/ui/deprecated.rs:26:27
-   |
-26 |     #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")]
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: use of deprecated constant `<FromPyWithTuple as pyo3::FromPyObject<'py>>::extract_bound::LIT_STR_DEPRECATION`: remove the quotes from the literal
-       = help: use `Bound :: < '_, PyAny > :: len` instead of `"Bound :: < '_, PyAny > :: len"`
-  --> tests/ui/deprecated.rs:33:27
-   |
-33 |     #[pyo3(from_py_with = "Bound::<'_, PyAny>::len")] usize,
-   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/immutable_type.rs b/tests/ui/immutable_type.rs
new file mode 100644
index 00000000000..a311eb5b249
--- /dev/null
+++ b/tests/ui/immutable_type.rs
@@ -0,0 +1,6 @@
+use pyo3::prelude::*;
+
+#[pyclass(immutable_type)]
+struct ImmutableType {}
+
+fn main() {}
diff --git a/tests/ui/immutable_type.stderr b/tests/ui/immutable_type.stderr
new file mode 100644
index 00000000000..45696c747a1
--- /dev/null
+++ b/tests/ui/immutable_type.stderr
@@ -0,0 +1,5 @@
+error: `immutable_type` requires Python >= 3.10 or >= 3.14 (ABI3)
+ --> tests/ui/immutable_type.rs:3:11
+  |
+3 | #[pyclass(immutable_type)]
+  |           ^^^^^^^^^^^^^^
diff --git a/tests/ui/invalid_argument_attributes.rs b/tests/ui/invalid_argument_attributes.rs
index 43f07c46191..e4066e5fd9c 100644
--- a/tests/ui/invalid_argument_attributes.rs
+++ b/tests/ui/invalid_argument_attributes.rs
@@ -13,7 +13,7 @@ fn from_py_with_string(#[pyo3("from_py_with")] _param: String) {}
 fn from_py_with_value_not_found(#[pyo3(from_py_with = func)] _param: String) {}
 
 #[pyfunction]
-fn from_py_with_repeated(#[pyo3(from_py_with = "func", from_py_with = "func")] _param: String) {}
+fn from_py_with_repeated(#[pyo3(from_py_with = func, from_py_with = func)] _param: String) {}
 
 fn bytes_from_py(bytes: &Bound<'_, pyo3::types::PyBytes>) -> Vec<u8> {
     bytes.as_bytes().to_vec()
diff --git a/tests/ui/invalid_argument_attributes.stderr b/tests/ui/invalid_argument_attributes.stderr
index d947402288d..d59558c16b9 100644
--- a/tests/ui/invalid_argument_attributes.stderr
+++ b/tests/ui/invalid_argument_attributes.stderr
@@ -17,33 +17,19 @@ error: expected `cancel_handle` or `from_py_with`
    |                               ^^^^^^^^^^^^^^
 
 error: `from_py_with` may only be specified once per argument
-  --> tests/ui/invalid_argument_attributes.rs:16:56
+  --> tests/ui/invalid_argument_attributes.rs:16:54
    |
-16 | fn from_py_with_repeated(#[pyo3(from_py_with = "func", from_py_with = "func")] _param: String) {}
-   |                                                        ^^^^^^^^^^^^
+16 | fn from_py_with_repeated(#[pyo3(from_py_with = func, from_py_with = func)] _param: String) {}
+   |                                                      ^^^^^^^^^^^^
 
-error[E0425]: cannot find value `func` in this scope
-  --> tests/ui/invalid_argument_attributes.rs:13:55
-   |
-13 | fn from_py_with_value_not_found(#[pyo3(from_py_with = func)] _param: String) {}
-   |                                                       ^^^^ not found in this scope
-
-warning: use of deprecated constant `__pyfunction_f::LIT_STR_DEPRECATION`: remove the quotes from the literal
-         = help: use `bytes_from_py` instead of `"bytes_from_py"`
+error: expected identifier
   --> tests/ui/invalid_argument_attributes.rs:23:28
    |
 23 | fn f(#[pyo3(from_py_with = "bytes_from_py")] _bytes: Vec<u8>) {}
    |                            ^^^^^^^^^^^^^^^
-   |
-   = note: `#[warn(deprecated)]` on by default
 
-error[E0308]: mismatched types
-  --> tests/ui/invalid_argument_attributes.rs:23:13
-   |
-22 | #[pyfunction]
-   | ------------- here the type of `from_py_with` is inferred to be `fn(&pyo3::Bound<'_, PyBytes>) -> Vec<u8>`
-23 | fn f(#[pyo3(from_py_with = "bytes_from_py")] _bytes: Vec<u8>) {}
-   |             ^^^^^^^^^^^^ expected `PyAny`, found `PyBytes`
+error[E0425]: cannot find value `func` in this scope
+  --> tests/ui/invalid_argument_attributes.rs:13:55
    |
-   = note: expected fn pointer `fn(&pyo3::Bound<'_, PyAny>) -> Result<_, PyErr>`
-              found fn pointer `fn(&pyo3::Bound<'_, PyBytes>) -> Vec<u8>`
+13 | fn from_py_with_value_not_found(#[pyo3(from_py_with = func)] _param: String) {}
+   |                                                       ^^^^ not found in this scope
diff --git a/tests/ui/invalid_cancel_handle.rs b/tests/ui/invalid_cancel_handle.rs
index cff6c5dcbad..b61397d4161 100644
--- a/tests/ui/invalid_cancel_handle.rs
+++ b/tests/ui/invalid_cancel_handle.rs
@@ -21,7 +21,7 @@ async fn missing_cancel_handle_attribute(_param: pyo3::coroutine::CancelHandle)
 
 #[pyfunction]
 async fn cancel_handle_and_from_py_with(
-    #[pyo3(cancel_handle, from_py_with = "cancel_handle")] _param: pyo3::coroutine::CancelHandle,
+    #[pyo3(cancel_handle, from_py_with = cancel_handle)] _param: pyo3::coroutine::CancelHandle,
 ) {
 }
 
diff --git a/tests/ui/invalid_cancel_handle.stderr b/tests/ui/invalid_cancel_handle.stderr
index 134b44ed7cf..a023d128bf2 100644
--- a/tests/ui/invalid_cancel_handle.stderr
+++ b/tests/ui/invalid_cancel_handle.stderr
@@ -19,7 +19,7 @@ error: `cancel_handle` attribute can only be used with `async fn`
 error: `from_py_with` and `cancel_handle` cannot be specified together
   --> tests/ui/invalid_cancel_handle.rs:24:12
    |
-24 |     #[pyo3(cancel_handle, from_py_with = "cancel_handle")] _param: pyo3::coroutine::CancelHandle,
+24 |     #[pyo3(cancel_handle, from_py_with = cancel_handle)] _param: pyo3::coroutine::CancelHandle,
    |            ^^^^^^^^^^^^^
 
 error[E0308]: mismatched types
diff --git a/tests/ui/invalid_frompy_derive.stderr b/tests/ui/invalid_frompy_derive.stderr
index afb6bbc97cb..484c4ce44f4 100644
--- a/tests/ui/invalid_frompy_derive.stderr
+++ b/tests/ui/invalid_frompy_derive.stderr
@@ -84,7 +84,7 @@ error: transparent structs and variants can only have 1 field
 70 | |     },
    | |_____^
 
-error: expected one of: `attribute`, `item`, `from_py_with`, `default`
+error: expected one of: `attribute`, `item`, `from_py_with`, `into_py_with`, `default`
   --> tests/ui/invalid_frompy_derive.rs:76:12
    |
 76 |     #[pyo3(attr)]
@@ -127,10 +127,10 @@ error: unexpected end of input, expected literal
     |                 ^
 
 error: only one of `attribute` or `item` can be provided
-   --> tests/ui/invalid_frompy_derive.rs:118:5
+   --> tests/ui/invalid_frompy_derive.rs:118:18
     |
 118 |     #[pyo3(item, attribute)]
-    |     ^
+    |                  ^^^^^^^^^
 
 error: expected one of: `transparent`, `from_item_all`, `annotation`, `crate`, `rename_all`
    --> tests/ui/invalid_frompy_derive.rs:123:8
@@ -194,7 +194,7 @@ error: `transparent` structs may not have a `getter` for the inner field
 186 |     field: String,
     |     ^^^^^
 
-error: `from_item_all` may only be provided once
+error: `from_item_all` may only be specified once
    --> tests/ui/invalid_frompy_derive.rs:190:23
     |
 190 | #[pyo3(from_item_all, from_item_all)]
@@ -244,7 +244,7 @@ error: `default` is not permitted on tuple struct elements.
 231 | struct NamedTuplesWithDefaultValues(#[pyo3(default)] String);
     |                                     ^
 
-error: `rename_all` may only be provided once
+error: `rename_all` may only be specified once
    --> tests/ui/invalid_frompy_derive.rs:234:34
     |
 234 | #[pyo3(rename_all = "camelCase", rename_all = "kebab-case")]
diff --git a/tests/ui/invalid_intopy_derive.rs b/tests/ui/invalid_intopy_derive.rs
index b609a740e56..5d65e36bfcb 100644
--- a/tests/ui/invalid_intopy_derive.rs
+++ b/tests/ui/invalid_intopy_derive.rs
@@ -138,4 +138,33 @@ enum EnumStructIntoPyWith {
     },
 }
 
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(transparent, rename_all = "camelCase")]
+struct StructTransparentRenameAll {
+    foo_bar: String,
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(rename_all = "camelCase")]
+struct StructTupleRenameAll(String, usize);
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumTransparentVariantRenameAll {
+    #[pyo3(rename_all = "camelCase")]
+    #[pyo3(transparent)]
+    Variant { foo: String },
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+enum EnumTupleVariantRenameAll {
+    #[pyo3(rename_all = "camelCase")]
+    Variant(String, usize),
+}
+
+#[derive(IntoPyObject, IntoPyObjectRef)]
+#[pyo3(rename_all = "camelCase")]
+enum EnumTopRenameAll {
+    Variant { foo: String },
+}
+
 fn main() {}
diff --git a/tests/ui/invalid_intopy_derive.stderr b/tests/ui/invalid_intopy_derive.stderr
index 4c04f8002a0..518066f3460 100644
--- a/tests/ui/invalid_intopy_derive.stderr
+++ b/tests/ui/invalid_intopy_derive.stderr
@@ -84,7 +84,7 @@ error: transparent structs and variants can only have 1 field
 70 | |     },
    | |_____^
 
-error: expected `transparent` or `crate`
+error: expected one of: `transparent`, `from_item_all`, `annotation`, `crate`, `rename_all`
   --> tests/ui/invalid_intopy_derive.rs:75:8
    |
 75 | #[pyo3(unknown = "should not work")]
@@ -102,25 +102,19 @@ error: cannot derive `IntoPyObject` for empty variants
 87 |     Unit,
    |     ^^^^
 
-error: `attribute` is not supported by `IntoPyObject`
+error: `item` and `attribute` are not permitted on tuple struct elements.
   --> tests/ui/invalid_intopy_derive.rs:91:30
    |
 91 | struct TupleAttribute(#[pyo3(attribute)] String, usize);
    |                              ^^^^^^^^^
 
-error: `item` is not permitted on tuple struct elements.
+error: `item` and `attribute` are not permitted on tuple struct elements.
   --> tests/ui/invalid_intopy_derive.rs:94:25
    |
 94 | struct TupleItem(#[pyo3(item)] String, usize);
    |                         ^^^^
 
-error: `attribute` is not supported by `IntoPyObject`
-  --> tests/ui/invalid_intopy_derive.rs:98:12
-   |
-98 |     #[pyo3(attribute)]
-   |            ^^^^^^^^^
-
-error: `transparent` structs may not have `item` for the inner field
+error: `transparent` structs may not have `item` nor `attribute` for the inner field
    --> tests/ui/invalid_intopy_derive.rs:105:12
     |
 105 |     #[pyo3(item)]
@@ -155,3 +149,33 @@ error: `into_py_with` is not permitted on `transparent` structs or variants
     |
 136 |         #[pyo3(into_py_with = into)]
     |                ^^^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_intopy_derive.rs:142:21
+    |
+142 | #[pyo3(transparent, rename_all = "camelCase")]
+    |                     ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_intopy_derive.rs:148:8
+    |
+148 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^
+
+error: `rename_all` is not permitted on `transparent` structs and variants
+   --> tests/ui/invalid_intopy_derive.rs:153:12
+    |
+153 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is useless on tuple structs and variants.
+   --> tests/ui/invalid_intopy_derive.rs:160:12
+    |
+160 |     #[pyo3(rename_all = "camelCase")]
+    |            ^^^^^^^^^^
+
+error: `rename_all` is not supported at top level for enums
+   --> tests/ui/invalid_intopy_derive.rs:165:8
+    |
+165 | #[pyo3(rename_all = "camelCase")]
+    |        ^^^^^^^^^^
diff --git a/tests/ui/invalid_proto_pymethods.stderr b/tests/ui/invalid_proto_pymethods.stderr
index 82c99c2ddc3..1f564d18ea0 100644
--- a/tests/ui/invalid_proto_pymethods.stderr
+++ b/tests/ui/invalid_proto_pymethods.stderr
@@ -22,6 +22,17 @@ error: `text_signature` cannot be used with magic method `__bool__`
 46 |     #[pyo3(name = "__bool__", text_signature = "")]
    |                               ^^^^^^^^^^^^^^
 
+error[E0592]: duplicate definitions with name `__pymethod___richcmp____`
+  --> tests/ui/invalid_proto_pymethods.rs:55:1
+   |
+55 | #[pymethods]
+   | ^^^^^^^^^^^^
+   | |
+   | duplicate definitions for `__pymethod___richcmp____`
+   | other definition for `__pymethod___richcmp____`
+   |
+   = note: this error originates in the macro `::pyo3::impl_::pyclass::generate_pyclass_richcompare_slot` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
 error[E0034]: multiple applicable items in scope
   --> tests/ui/invalid_proto_pymethods.rs:55:1
    |
@@ -40,17 +51,6 @@ note: candidate #2 is defined in an impl for the type `EqAndRichcmp`
    | ^^^^^^^^^^^^
    = note: this error originates in the macro `::pyo3::impl_::pyclass::generate_pyclass_richcompare_slot` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0592]: duplicate definitions with name `__pymethod___richcmp____`
-  --> tests/ui/invalid_proto_pymethods.rs:55:1
-   |
-55 | #[pymethods]
-   | ^^^^^^^^^^^^
-   | |
-   | duplicate definitions for `__pymethod___richcmp____`
-   | other definition for `__pymethod___richcmp____`
-   |
-   = note: this error originates in the macro `::pyo3::impl_::pyclass::generate_pyclass_richcompare_slot` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
-
 error[E0034]: multiple applicable items in scope
   --> tests/ui/invalid_proto_pymethods.rs:55:1
    |
diff --git a/tests/ui/invalid_pyclass_args.stderr b/tests/ui/invalid_pyclass_args.stderr
index c13edc071d5..f75355b080e 100644
--- a/tests/ui/invalid_pyclass_args.stderr
+++ b/tests/ui/invalid_pyclass_args.stderr
@@ -1,4 +1,4 @@
-error: expected one of: `crate`, `dict`, `eq`, `eq_int`, `extends`, `freelist`, `frozen`, `get_all`, `hash`, `mapping`, `module`, `name`, `ord`, `rename_all`, `sequence`, `set_all`, `str`, `subclass`, `unsendable`, `weakref`
+error: expected one of: `crate`, `dict`, `eq`, `eq_int`, `extends`, `freelist`, `frozen`, `get_all`, `hash`, `immutable_type`, `mapping`, `module`, `name`, `ord`, `rename_all`, `sequence`, `set_all`, `str`, `subclass`, `unsendable`, `weakref`, `generic`
  --> tests/ui/invalid_pyclass_args.rs:4:11
   |
 4 | #[pyclass(extend=pyo3::types::PyDict)]
@@ -46,7 +46,7 @@ error: expected string literal
 25 | #[pyclass(module = my_module)]
    |                    ^^^^^^^^^
 
-error: expected one of: `crate`, `dict`, `eq`, `eq_int`, `extends`, `freelist`, `frozen`, `get_all`, `hash`, `mapping`, `module`, `name`, `ord`, `rename_all`, `sequence`, `set_all`, `str`, `subclass`, `unsendable`, `weakref`
+error: expected one of: `crate`, `dict`, `eq`, `eq_int`, `extends`, `freelist`, `frozen`, `get_all`, `hash`, `immutable_type`, `mapping`, `module`, `name`, `ord`, `rename_all`, `sequence`, `set_all`, `str`, `subclass`, `unsendable`, `weakref`, `generic`
   --> tests/ui/invalid_pyclass_args.rs:28:11
    |
 28 | #[pyclass(weakrev)]
diff --git a/tests/ui/invalid_pyclass_generic.rs b/tests/ui/invalid_pyclass_generic.rs
new file mode 100644
index 00000000000..45cd5fec9b0
--- /dev/null
+++ b/tests/ui/invalid_pyclass_generic.rs
@@ -0,0 +1,24 @@
+use pyo3::prelude::*;
+use pyo3::types::PyType;
+
+#[pyclass(generic)]
+struct ClassRedefinesClassGetItem {
+}
+
+#[pymethods]
+impl ClassRedefinesClassGetItem {
+    #[new]
+    fn new() -> ClassRedefinesClassGetItem {
+        Self {}
+    }
+
+    #[classmethod]
+    pub fn __class_getitem__(
+        cls: &Bound<'_, PyType>,
+        key: &Bound<'_, PyAny>,
+    ) -> PyResult<PyObject> {
+        pyo3::types::PyGenericAlias::new(cls.py(), cls.as_any(), key)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/invalid_pyclass_generic.stderr b/tests/ui/invalid_pyclass_generic.stderr
new file mode 100644
index 00000000000..1381c31e1e1
--- /dev/null
+++ b/tests/ui/invalid_pyclass_generic.stderr
@@ -0,0 +1,136 @@
+error[E0592]: duplicate definitions with name `__pymethod___class_getitem____`
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^ duplicate definitions for `__pymethod___class_getitem____`
+...
+8 | #[pymethods]
+  | ------------ other definition for `__pymethod___class_getitem____`
+  |
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0592]: duplicate definitions with name `__class_getitem__`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+4  |   #[pyclass(generic)]
+   |   ^^^^^^^^^^^^^^^^^^^ duplicate definitions for `__class_getitem__`
+...
+16 | /     pub fn __class_getitem__(
+17 | |         cls: &Bound<'_, PyType>,
+18 | |         key: &Bound<'_, PyAny>,
+19 | |     ) -> PyResult<PyObject> {
+   | |___________________________- other definition for `__class_getitem__`
+   |
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^ multiple `__pymethod___class_getitem____` found
+  |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+ --> tests/ui/invalid_pyclass_generic.rs:8:1
+  |
+8 | #[pymethods]
+  | ^^^^^^^^^^^^
+  = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+4  | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^ multiple `__class_getitem__` found
+   |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+4  | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:16:5
+   |
+16 | /     pub fn __class_getitem__(
+17 | |         cls: &Bound<'_, PyType>,
+18 | |         key: &Bound<'_, PyAny>,
+19 | |     ) -> PyResult<PyObject> {
+   | |___________________________^
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+ --> tests/ui/invalid_pyclass_generic.rs:4:1
+  |
+4 | #[pyclass(generic)]
+  | ^^^^^^^^^^^^^^^^^^^ multiple `wrap` found
+  |
+  = note: candidate #1 is defined in an impl for the type `IntoPyObjectConverter<Result<T, E>>`
+  = note: candidate #2 is defined in an impl for the type `IntoPyObjectConverter<T>`
+  = note: candidate #3 is defined in an impl for the type `UnknownReturnResultType<Result<T, E>>`
+  = note: candidate #4 is defined in an impl for the type `UnknownReturnType<T>`
+  = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0308]: mismatched types
+  --> tests/ui/invalid_pyclass_generic.rs:20:9
+   |
+19 |     ) -> PyResult<PyObject> {
+   |          ------------------ expected `Result<Py<pyo3::PyAny>, PyErr>` because of return type
+20 |         pyo3::types::PyGenericAlias::new(cls.py(), cls.as_any(), key)
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Result<Py<PyAny>, PyErr>`, found `Result<Bound<'_, PyGenericAlias>, PyErr>`
+   |
+   = note: expected enum `Result<Py<pyo3::PyAny>, PyErr>`
+              found enum `Result<pyo3::Bound<'_, PyGenericAlias>, PyErr>`
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:16:12
+   |
+16 |     pub fn __class_getitem__(
+   |            ^^^^^^^^^^^^^^^^^ multiple `__pymethod___class_getitem____` found
+   |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+4  | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:8:1
+   |
+8  | #[pymethods]
+   | ^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `pyclass` which comes from the expansion of the attribute macro `pymethods` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:16:12
+   |
+16 |     pub fn __class_getitem__(
+   |            ^^^^^^^^^^^^^^^^^ multiple `__class_getitem__` found
+   |
+note: candidate #1 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:4:1
+   |
+4  | #[pyclass(generic)]
+   | ^^^^^^^^^^^^^^^^^^^
+note: candidate #2 is defined in an impl for the type `ClassRedefinesClassGetItem`
+  --> tests/ui/invalid_pyclass_generic.rs:16:5
+   |
+16 | /     pub fn __class_getitem__(
+17 | |         cls: &Bound<'_, PyType>,
+18 | |         key: &Bound<'_, PyAny>,
+19 | |     ) -> PyResult<PyObject> {
+   | |___________________________^
+   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0034]: multiple applicable items in scope
+  --> tests/ui/invalid_pyclass_generic.rs:19:10
+   |
+19 |     ) -> PyResult<PyObject> {
+   |          ^^^^^^^^ multiple `wrap` found
+   |
+   = note: candidate #1 is defined in an impl for the type `IntoPyObjectConverter<Result<T, E>>`
+   = note: candidate #2 is defined in an impl for the type `IntoPyObjectConverter<T>`
+   = note: candidate #3 is defined in an impl for the type `UnknownReturnResultType<Result<T, E>>`
+   = note: candidate #4 is defined in an impl for the type `UnknownReturnType<T>`
diff --git a/tests/ui/invalid_pymodule_trait.stderr b/tests/ui/invalid_pymodule_trait.stderr
index 0b0d46da93d..f8cfc1b1bdf 100644
--- a/tests/ui/invalid_pymodule_trait.stderr
+++ b/tests/ui/invalid_pymodule_trait.stderr
@@ -1,4 +1,4 @@
-error: `#[pymodule_export]` may only be used on `use` statements
+error: `#[pymodule_export]` may only be used on `use` or `const` statements
  --> tests/ui/invalid_pymodule_trait.rs:5:5
   |
 5 |     #[pymodule_export]
diff --git a/tests/ui/pyclass_generic_enum.rs b/tests/ui/pyclass_generic_enum.rs
new file mode 100644
index 00000000000..94fd779b2d4
--- /dev/null
+++ b/tests/ui/pyclass_generic_enum.rs
@@ -0,0 +1,15 @@
+use pyo3::prelude::*;
+
+#[pyclass(generic)]
+enum NotGenericForEnum {
+    A,
+    B,
+}
+
+#[pyclass(generic)]
+enum NoGenericForComplexEnum {
+    A { x: f64 },
+    B { y: f64, z: f64 },
+}
+
+fn main() {}
diff --git a/tests/ui/pyclass_generic_enum.stderr b/tests/ui/pyclass_generic_enum.stderr
new file mode 100644
index 00000000000..cfc1e178af3
--- /dev/null
+++ b/tests/ui/pyclass_generic_enum.stderr
@@ -0,0 +1,11 @@
+error: enums do not support #[pyclass(generic)]
+ --> tests/ui/pyclass_generic_enum.rs:3:11
+  |
+3 | #[pyclass(generic)]
+  |           ^^^^^^^
+
+error: enums do not support #[pyclass(generic)]
+ --> tests/ui/pyclass_generic_enum.rs:9:11
+  |
+9 | #[pyclass(generic)]
+  |           ^^^^^^^
diff --git a/tests/ui/pyclass_send.stderr b/tests/ui/pyclass_send.stderr
index 1623a5b2183..334c36daa13 100644
--- a/tests/ui/pyclass_send.stderr
+++ b/tests/ui/pyclass_send.stderr
@@ -1,24 +1,3 @@
-error[E0277]: `*mut c_void` cannot be shared between threads safely
- --> tests/ui/pyclass_send.rs:5:8
-  |
-5 | struct NotSyncNotSend(*mut c_void);
-  |        ^^^^^^^^^^^^^^ `*mut c_void` cannot be shared between threads safely
-  |
-  = help: within `NotSyncNotSend`, the trait `Sync` is not implemented for `*mut c_void`
-note: required because it appears within the type `NotSyncNotSend`
- --> tests/ui/pyclass_send.rs:5:8
-  |
-5 | struct NotSyncNotSend(*mut c_void);
-  |        ^^^^^^^^^^^^^^
-note: required by a bound in `assert_pyclass_sync`
- --> src/impl_/pyclass/assertions.rs
-  |
-  | pub const fn assert_pyclass_sync<T>()
-  |              ------------------- required by a bound in this function
-  | where
-  |     T: PyClassSync + Sync,
-  |                      ^^^^ required by this bound in `assert_pyclass_sync`
-
 error[E0277]: `*mut c_void` cannot be sent between threads safely
  --> tests/ui/pyclass_send.rs:4:1
   |
@@ -40,27 +19,6 @@ note: required by a bound in `PyClassImpl::ThreadChecker`
   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `PyClassImpl::ThreadChecker`
   = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0277]: `*mut c_void` cannot be shared between threads safely
- --> tests/ui/pyclass_send.rs:8:8
-  |
-8 | struct SendNotSync(*mut c_void);
-  |        ^^^^^^^^^^^ `*mut c_void` cannot be shared between threads safely
-  |
-  = help: within `SendNotSync`, the trait `Sync` is not implemented for `*mut c_void`
-note: required because it appears within the type `SendNotSync`
- --> tests/ui/pyclass_send.rs:8:8
-  |
-8 | struct SendNotSync(*mut c_void);
-  |        ^^^^^^^^^^^
-note: required by a bound in `assert_pyclass_sync`
- --> src/impl_/pyclass/assertions.rs
-  |
-  | pub const fn assert_pyclass_sync<T>()
-  |              ------------------- required by a bound in this function
-  | where
-  |     T: PyClassSync + Sync,
-  |                      ^^^^ required by this bound in `assert_pyclass_sync`
-
 error[E0277]: `*mut c_void` cannot be sent between threads safely
   --> tests/ui/pyclass_send.rs:11:1
    |
@@ -119,3 +77,45 @@ note: required by a bound in `SendablePyClass`
    | pub struct SendablePyClass<T: Send>(PhantomData<T>);
    |                               ^^^^ required by this bound in `SendablePyClass`
    = note: this error originates in the attribute macro `pyclass` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: `*mut c_void` cannot be shared between threads safely
+ --> tests/ui/pyclass_send.rs:5:8
+  |
+5 | struct NotSyncNotSend(*mut c_void);
+  |        ^^^^^^^^^^^^^^ `*mut c_void` cannot be shared between threads safely
+  |
+  = help: within `NotSyncNotSend`, the trait `Sync` is not implemented for `*mut c_void`
+note: required because it appears within the type `NotSyncNotSend`
+ --> tests/ui/pyclass_send.rs:5:8
+  |
+5 | struct NotSyncNotSend(*mut c_void);
+  |        ^^^^^^^^^^^^^^
+note: required by a bound in `assert_pyclass_sync`
+ --> src/impl_/pyclass/assertions.rs
+  |
+  | pub const fn assert_pyclass_sync<T>()
+  |              ------------------- required by a bound in this function
+  | where
+  |     T: PyClassSync + Sync,
+  |                      ^^^^ required by this bound in `assert_pyclass_sync`
+
+error[E0277]: `*mut c_void` cannot be shared between threads safely
+ --> tests/ui/pyclass_send.rs:8:8
+  |
+8 | struct SendNotSync(*mut c_void);
+  |        ^^^^^^^^^^^ `*mut c_void` cannot be shared between threads safely
+  |
+  = help: within `SendNotSync`, the trait `Sync` is not implemented for `*mut c_void`
+note: required because it appears within the type `SendNotSync`
+ --> tests/ui/pyclass_send.rs:8:8
+  |
+8 | struct SendNotSync(*mut c_void);
+  |        ^^^^^^^^^^^
+note: required by a bound in `assert_pyclass_sync`
+ --> src/impl_/pyclass/assertions.rs
+  |
+  | pub const fn assert_pyclass_sync<T>()
+  |              ------------------- required by a bound in this function
+  | where
+  |     T: PyClassSync + Sync,
+  |                      ^^^^ required by this bound in `assert_pyclass_sync`
diff --git a/tests/ui/reject_generics.stderr b/tests/ui/reject_generics.stderr
index fed5d48937e..9b16f1d68e7 100644
--- a/tests/ui/reject_generics.stderr
+++ b/tests/ui/reject_generics.stderr
@@ -1,10 +1,10 @@
-error: #[pyclass] cannot have generic parameters. For an explanation, see https://pyo3.rs/v0.25.0-dev/class.html#no-generic-parameters
+error: #[pyclass] cannot have generic parameters. For an explanation, see https://pyo3.rs/v0.25.0/class.html#no-generic-parameters
  --> tests/ui/reject_generics.rs:4:25
   |
 4 | struct ClassWithGenerics<A> {
   |                         ^
 
-error: #[pyclass] cannot have lifetime parameters. For an explanation, see https://pyo3.rs/v0.25.0-dev/class.html#no-lifetime-parameters
+error: #[pyclass] cannot have lifetime parameters. For an explanation, see https://pyo3.rs/v0.25.0/class.html#no-lifetime-parameters
  --> tests/ui/reject_generics.rs:9:27
   |
 9 | struct ClassWithLifetimes<'a> {