diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 62b3e2d..d129ce0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,6 +10,19 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
+  resolve:
+    runs-on: ubuntu-latest
+    outputs:
+      MSRV: ${{ steps.resolve-msrv.outputs.MSRV }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: resolve MSRV
+        id: resolve-msrv
+        run: echo MSRV=`python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["package"]["rust-version"])'` >> $GITHUB_OUTPUT
+
   fmt:
     runs-on: ubuntu-latest
     steps:
@@ -30,27 +43,27 @@ jobs:
       - run: cargo clippy --all
 
   build:
-    needs: [fmt] # don't wait for clippy as fails rarely and takes longer
+    needs: [resolve, fmt] # don't wait for clippy as fails rarely and takes longer
     name: python${{ matrix.python-version }} ${{ matrix.os }} rust-${{ matrix.rust}}
     runs-on: ${{ matrix.os }}
     strategy:
-      fail-fast: false  # If one platform fails, allow the rest to keep testing.
+      fail-fast: false # If one platform fails, allow the rest to keep testing.
       matrix:
-        python-architecture: ["x64"]
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
-        os: [
-          "macos-13",
-          "ubuntu-latest",
-          "windows-latest",
-        ]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13", "3.14", "3.14t", "3.15-dev", "3.15t-dev"]
+        os: ["macos-latest", "ubuntu-latest", "windows-latest"]
         rust: [stable]
         include:
-          - python-version: "3.12"
+          - python-version: "3.14"
             os: "ubuntu-latest"
-            rust: "1.63"
-          - python-version: "3.12"
-            python-architecture: "arm64"
-            os: "macos-latest"
+            rust: ${{ needs.resolve.outputs.MSRV }}
+          - python-version: "3.14"
+            os: "macos-15-intel"
+            rust: "stable"
+          - python-version: "3.14"
+            os: "ubuntu-24.04-arm"
+            rust: "stable"
+          - python-version: "3.14"
+            os: "windows-11-arm"
             rust: "stable"
 
     steps:
@@ -60,7 +73,6 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
-          architecture: ${{ matrix.python-python-architecture }}
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@master
@@ -70,11 +82,20 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         continue-on-error: true
 
+      - if: ${{ matrix.rust == needs.resolve.outputs.MSRV }}
+        name: Set dependencies on MSRV
+        run: cargo +stable update
+        env:
+          CARGO_RESOLVER_INCOMPATIBLE_RUST_VERSIONS: fallback
+
       - name: Test
         run: cargo test --verbose
 
       - name: Test (abi3)
-        run: cargo test --verbose --features pyo3/abi3-py37
+        run: cargo test --verbose --features pyo3/abi3-py38
+
+      - name: Test (arbitrary_precision)
+        run: cargo test --verbose --features arbitrary_precision
 
     env:
       RUST_BACKTRACE: 1
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..f538d3d
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,32 @@
+name: Release Rust Crate
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: The version to build
+
+jobs:
+  release:
+    permissions:
+      id-token: write
+
+    runs-on: ubuntu-latest
+    environment: release
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          # The tag to build or the tag received by the tag event
+          ref: ${{ github.event.inputs.version || github.ref }}
+          persist-credentials: false
+
+      - uses: rust-lang/crates-io-auth-action@v1
+        id: auth
+
+      - name: Publish to crates.io
+        run: cargo publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7d584aa..b3202ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,45 @@
+## 0.29.0 - 2026-05-12
+
+- Update `pyo3` to 0.29.
+- Support serializing `i128` and `u128`.
+
+## 0.28.0 - 2026-02-18
+
+- Bump MSRV to 1.83.
+- Update `pyo3` to 0.28.
+- Support deserializing `dataclass` instances to struct-like Rust types.
+- Add `arbitrary_precision` feature
+
+## 0.27.0 - 2025-11-07
+- Update to PyO3 0.27
+
+## 0.26.0 - 2025-08-30
+
+### Packaging
+- Bump MSRV to 1.74
+- Update to PyO3 0.26
+
+### Changed
+- `PythonizeTypes`, `PythonizeMappingType` and `PythonizeNamedMappingType` no longer have a lifetime on the trait, instead the `Builder` type is a GAT.
+
+## 0.25.0 - 2025-05-23
+
+### Packaging
+- Update to PyO3 0.25
+
+## 0.24.0 - 2025-03-26
+
+### Packaging
+- Update to PyO3 0.24
+
+## Removed
+- Remove deprecated `depythonize_bound()`
+
+## 0.23.0 - 2024-11-22
+
+### Packaging
+- Update to PyO3 0.23
+
 ## 0.22.0 - 2024-08-10
 
 ### Packaging
diff --git a/Cargo.toml b/Cargo.toml
index 415f5b9..db1f21f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,9 @@
 [package]
 name = "pythonize"
-version = "0.22.0"
+version = "0.29.0"
 authors = ["David Hewitt <1939362+davidhewitt@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.63"
+rust-version = "1.83"
 license = "MIT"
 description = "Serde Serializer & Deserializer from Rust <--> Python, backed by PyO3."
 homepage = "https://github.com/davidhewitt/pythonize"
@@ -13,12 +13,16 @@ documentation = "https://docs.rs/crate/pythonize/"
 
 [dependencies]
 serde = { version = "1.0", default-features = false, features = ["std"] }
-pyo3 = { version = "0.22.2", default-features = false }
+serde_json = { version = "1.0", optional = true, default-features = false, features = ["std"] }
+pyo3 = { version = "0.29", default-features = false }
 
 [dev-dependencies]
 serde = { version = "1.0", default-features = false, features = ["derive"] }
-pyo3 = { version = "0.22.2", default-features = false, features = ["auto-initialize", "macros", "py-clone"] }
-serde_json = "1.0"
+pyo3 = { version = "0.29", default-features = false, features = ["auto-initialize", "macros", "py-clone"] }
+serde_json = { version = "1.0", default-features = false, features = ["std"] }
 serde_bytes = "0.11"
 maplit = "1.0.2"
 serde_path_to_error = "0.1.15"
+
+[features]
+arbitrary_precision = ["serde_json", "serde_json/arbitrary_precision"]
diff --git a/README.md b/README.md
index 441f29f..a59bd22 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Pythonize
 
-This is an experimental serializer for Rust's serde ecosystem, which can convert Rust objects to Python values and back.
+This is a serializer for Rust's serde ecosystem, which can convert Rust objects to Python values and back.
 
 At the moment the Python structures it produces should be _very_ similar to those which are produced by `serde_json`; i.e. calling Python's `json.loads()` on a value encoded by `serde_json` should produce an identical structure to
 that which is produced directly by `pythonize`.
@@ -17,7 +17,7 @@ Pythonize has two main public APIs: `pythonize` and `depythonize`.
 [Serde]: https://github.com/serde-rs/serde
 [PyO3]: https://github.com/PyO3/pyo3
 
-# Examples
+## Examples
 
 ```rust
 use serde::{Serialize, Deserialize};
@@ -35,7 +35,7 @@ let sample = Sample {
     bar: None
 };
 
-Python::with_gil(|py| {
+Python::attach(|py| {
     // Rust -> Python
     let obj =  pythonize(py, &sample).unwrap();
 
@@ -47,3 +47,14 @@ Python::with_gil(|py| {
     assert_eq!(new_sample, sample);
 })
 ```
+
+## Features
+
+### `arbitrary_precision`
+
+Enable support for `serde_json`'s `arbitrary_precision` feature, which allows handling numbers that exceed the range of `i128`/`u128` when converting `serde_json::Value` to and from Python.
+
+```toml
+[dependencies]
+pythonize = { version = "0.29", features = ["arbitrary_precision"] }
+```
diff --git a/src/de.rs b/src/de.rs
index b2dcbdf..07728b8 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -1,10 +1,23 @@
-use pyo3::{types::*, Bound};
-use serde::de::{self, DeserializeOwned, IntoDeserializer};
+use pyo3::exceptions::PyKeyError;
+use pyo3::{intern, types::*, Bound};
+use serde::de::{self, IntoDeserializer};
 use serde::Deserialize;
 
 use crate::error::{ErrorImpl, PythonizeError, Result};
 
-/// Attempt to convert a Python object to an instance of `T`
+#[cfg(feature = "arbitrary_precision")]
+const TOKEN: &str = "$serde_json::private::Number";
+
+/// Attempt to convert a Python object to an instance of `T`.
+///
+/// Generally this only supports Python types that match `serde`'s object model well:
+/// - integers (including arbitrary precision integers if the `arbitrary_precision` feature is enabled)
+/// - floats
+/// - strings
+/// - bytes
+/// - `collections.abc.Sequence` instances (as serde sequences)
+/// - `collections.abc.Mapping` instances (as serde maps)
+/// - dataclasses (as serde maps)
 pub fn depythonize<'a, 'py, T>(obj: &'a Bound<'py, PyAny>) -> Result<T>
 where
     T: Deserialize<'a>,
@@ -12,15 +25,6 @@ where
     T::deserialize(&mut Depythonizer::from_object(obj))
 }
 
-/// Attempt to convert a Python object to an instance of `T`
-#[deprecated(since = "0.22.0", note = "use `depythonize` instead")]
-pub fn depythonize_bound<'py, T>(obj: Bound<'py, PyAny>) -> Result<T>
-where
-    T: DeserializeOwned,
-{
-    T::deserialize(&mut Depythonizer::from_object(&obj))
-}
-
 /// A structure that deserializes Python objects into Rust values
 pub struct Depythonizer<'a, 'py> {
     input: &'a Bound<'py, PyAny>,
@@ -33,7 +37,7 @@ impl<'a, 'py> Depythonizer<'a, 'py> {
     }
 
     fn sequence_access(&self, expected_len: Option<usize>) -> Result<PySequenceAccess<'a, 'py>> {
-        let seq = self.input.downcast::<PySequence>()?;
+        let seq = self.input.cast::<PySequence>()?;
         let len = self.input.len()?;
 
         match expected_len {
@@ -45,11 +49,11 @@ impl<'a, 'py> Depythonizer<'a, 'py> {
     }
 
     fn set_access(&self) -> Result<PySetAsSequence<'py>> {
-        match self.input.downcast::<PySet>() {
-            Ok(set) => Ok(PySetAsSequence::from_set(&set)),
+        match self.input.cast::<PySet>() {
+            Ok(set) => Ok(PySetAsSequence::from_set(set)),
             Err(e) => {
-                if let Ok(f) = self.input.downcast::<PyFrozenSet>() {
-                    Ok(PySetAsSequence::from_frozenset(&f))
+                if let Ok(f) = self.input.cast::<PyFrozenSet>() {
+                    Ok(PySetAsSequence::from_frozenset(f))
                 } else {
                     Err(e.into())
                 }
@@ -58,7 +62,15 @@ impl<'a, 'py> Depythonizer<'a, 'py> {
     }
 
     fn dict_access(&self) -> Result<PyMappingAccess<'py>> {
-        PyMappingAccess::new(self.input.downcast()?)
+        PyMappingAccess::new(self.input.cast()?)
+    }
+
+    fn dataclass_access(&self) -> Result<Option<PyDataclassAccess<'py>>> {
+        if let Some(dc) = DataclassCandidate::try_new(self.input) {
+            Some(PyDataclassAccess::new(dc)).transpose()
+        } else {
+            Ok(None)
+        }
     }
 
     fn deserialize_any_int<'de, V>(&self, int: &Bound<'_, PyInt>, visitor: V) -> Result<V::Value>
@@ -77,8 +89,7 @@ impl<'a, 'py> Depythonizer<'a, 'py> {
             } else {
                 visitor.visit_u128(x)
             }
-        } else {
-            let x: i128 = int.extract()?;
+        } else if let Ok(x) = int.extract::<i128>() {
             if let Ok(x) = i8::try_from(x) {
                 visitor.visit_i8(x)
             } else if let Ok(x) = i16::try_from(x) {
@@ -90,6 +101,19 @@ impl<'a, 'py> Depythonizer<'a, 'py> {
             } else {
                 visitor.visit_i128(x)
             }
+        } else {
+            #[cfg(feature = "arbitrary_precision")]
+            {
+                visitor.visit_map(NumberDeserializer {
+                    number: Some(int.to_string()),
+                })
+            }
+            #[cfg(not(feature = "arbitrary_precision"))]
+            {
+                // Re-attempt to return the original error.
+                let _: i128 = int.extract()?;
+                unreachable!()
+            }
         }
     }
 }
@@ -120,7 +144,7 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
             self.deserialize_unit(visitor)
         } else if obj.is_instance_of::<PyBool>() {
             self.deserialize_bool(visitor)
-        } else if let Ok(x) = obj.downcast::<PyInt>() {
+        } else if let Ok(x) = obj.cast::<PyInt>() {
             self.deserialize_any_int(x, visitor)
         } else if obj.is_instance_of::<PyList>() || obj.is_instance_of::<PyTuple>() {
             self.deserialize_tuple(obj.len()?, visitor)
@@ -130,17 +154,19 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
             self.deserialize_str(visitor)
         }
         // Continue with cases which are slower to check because they go
-        // throuh `isinstance` machinery
+        // through `isinstance` machinery
         else if obj.is_instance_of::<PyBytes>() || obj.is_instance_of::<PyByteArray>() {
             self.deserialize_bytes(visitor)
         } else if obj.is_instance_of::<PyFloat>() {
             self.deserialize_f64(visitor)
         } else if obj.is_instance_of::<PyFrozenSet>() || obj.is_instance_of::<PySet>() {
             self.deserialize_seq(visitor)
-        } else if obj.downcast::<PySequence>().is_ok() {
+        } else if obj.cast::<PySequence>().is_ok() {
             self.deserialize_tuple(obj.len()?, visitor)
-        } else if obj.downcast::<PyMapping>().is_ok() {
+        } else if obj.cast::<PyMapping>().is_ok() {
             self.deserialize_map(visitor)
+        } else if let Some(dc) = DataclassCandidate::try_new(obj) {
+            visitor.visit_map(PyDataclassAccess::new(dc)?)
         } else {
             Err(obj.get_type().qualname().map_or_else(
                 |_| PythonizeError::unsupported_type("unknown"),
@@ -160,8 +186,8 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
     where
         V: de::Visitor<'de>,
     {
-        let s = self.input.downcast::<PyString>()?.to_cow()?;
-        if s.len() != 1 {
+        let s = self.input.cast::<PyString>()?.to_cow()?;
+        if s.chars().count() != 1 {
             return Err(PythonizeError::invalid_length_char());
         }
         visitor.visit_char(s.chars().next().unwrap())
@@ -184,7 +210,7 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
     where
         V: de::Visitor<'de>,
     {
-        let s = self.input.downcast::<PyString>()?;
+        let s = self.input.cast::<PyString>()?;
         visitor.visit_str(&s.to_cow()?)
     }
 
@@ -199,7 +225,7 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
     where
         V: de::Visitor<'de>,
     {
-        let b = self.input.downcast::<PyBytes>()?;
+        let b = self.input.cast::<PyBytes>()?;
         visitor.visit_bytes(b.as_bytes())
     }
 
@@ -287,7 +313,11 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
     where
         V: de::Visitor<'de>,
     {
-        visitor.visit_map(self.dict_access()?)
+        if let Some(dc_access) = self.dataclass_access()? {
+            visitor.visit_map(dc_access)
+        } else {
+            visitor.visit_map(self.dict_access()?)
+        }
     }
 
     fn deserialize_struct<V>(
@@ -312,9 +342,9 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
         V: de::Visitor<'de>,
     {
         let item = &self.input;
-        if let Ok(s) = item.downcast::<PyString>() {
+        if let Ok(s) = item.cast::<PyString>() {
             visitor.visit_enum(s.to_cow()?.into_deserializer())
-        } else if let Ok(m) = item.downcast::<PyMapping>() {
+        } else if let Ok(m) = item.cast::<PyMapping>() {
             // Get the enum variant from the mapping key
             if m.len()? != 1 {
                 return Err(PythonizeError::invalid_length_enum());
@@ -322,7 +352,7 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
             let variant: Bound<PyString> = m
                 .keys()?
                 .get_item(0)?
-                .downcast_into::<PyString>()
+                .cast_into::<PyString>()
                 .map_err(|_| PythonizeError::dict_key_not_string())?;
             let value = m.get_item(&variant)?;
             visitor.visit_enum(PyEnumAccess::new(&value, variant))
@@ -337,7 +367,7 @@ impl<'de> de::Deserializer<'de> for &'_ mut Depythonizer<'_, '_> {
     {
         let s = self
             .input
-            .downcast::<PyString>()
+            .cast::<PyString>()
             .map_err(|_| PythonizeError::dict_key_not_string())?;
         visitor.visit_str(&s.to_cow()?)
     }
@@ -387,13 +417,13 @@ struct PySetAsSequence<'py> {
 impl<'py> PySetAsSequence<'py> {
     fn from_set(set: &Bound<'py, PySet>) -> Self {
         Self {
-            iter: PyIterator::from_bound_object(&set).expect("set is always iterable"),
+            iter: PyIterator::from_object(set).expect("set is always iterable"),
         }
     }
 
     fn from_frozenset(set: &Bound<'py, PyFrozenSet>) -> Self {
         Self {
-            iter: PyIterator::from_bound_object(&set).expect("frozenset is always iterable"),
+            iter: PyIterator::from_object(set).expect("frozenset is always iterable"),
         }
     }
 }
@@ -415,8 +445,8 @@ impl<'de> de::SeqAccess<'de> for PySetAsSequence<'_> {
 }
 
 struct PyMappingAccess<'py> {
-    keys: Bound<'py, PySequence>,
-    values: Bound<'py, PySequence>,
+    keys: Bound<'py, PyList>,
+    values: Bound<'py, PyList>,
     key_idx: usize,
     val_idx: usize,
     len: usize,
@@ -464,6 +494,79 @@ impl<'de> de::MapAccess<'de> for PyMappingAccess<'_> {
     }
 }
 
+/// Intermediate structure used to denote that `obj` is a dataclass with `fields`.
+struct DataclassCandidate<'a, 'py> {
+    obj: &'a Bound<'py, PyAny>,
+    fields: Bound<'py, PyAny>,
+}
+
+impl<'a, 'py> DataclassCandidate<'a, 'py> {
+    fn try_new(obj: &'a Bound<'py, PyAny>) -> Option<Self> {
+        let fields = obj
+            .getattr_opt(intern!(obj.py(), "__dataclass_fields__"))
+            .ok()
+            .flatten()?;
+        Some(Self { obj, fields })
+    }
+}
+
+struct PyDataclassAccess<'py> {
+    fields: Bound<'py, PyList>,
+    dict: Bound<'py, PyDict>,
+    field_idx: usize,
+    val_idx: usize,
+    len: usize,
+}
+
+impl<'py> PyDataclassAccess<'py> {
+    fn new(dc: DataclassCandidate<'_, 'py>) -> Result<Self> {
+        let fields = dc.fields.cast::<PyDict>()?.keys();
+        let dict = dc
+            .obj
+            .getattr(intern!(dc.obj.py(), "__dict__"))?
+            .cast_into()?;
+        let len = fields.len();
+        Ok(Self {
+            fields,
+            dict,
+            field_idx: 0,
+            val_idx: 0,
+            len,
+        })
+    }
+}
+
+impl<'de> de::MapAccess<'de> for PyDataclassAccess<'_> {
+    type Error = PythonizeError;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        if self.field_idx < self.len {
+            let item = self.fields.get_item(self.field_idx)?;
+            self.field_idx += 1;
+            seed.deserialize(&mut Depythonizer::from_object(&item))
+                .map(Some)
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        let key = self.fields.get_item(self.val_idx)?;
+        let value = self
+            .dict
+            .get_item(&key)?
+            .ok_or_else(|| PyKeyError::new_err(key.unbind()))?;
+        self.val_idx += 1;
+        seed.deserialize(&mut Depythonizer::from_object(&value))
+    }
+}
+
 struct PyEnumAccess<'a, 'py> {
     de: Depythonizer<'a, 'py>,
     variant: Bound<'py, PyString>,
@@ -522,31 +625,65 @@ impl<'de> de::VariantAccess<'de> for PyEnumAccess<'_, '_> {
     }
 }
 
+// See serde_json
+#[cfg(feature = "arbitrary_precision")]
+struct NumberDeserializer {
+    number: Option<String>,
+}
+
+#[cfg(feature = "arbitrary_precision")]
+impl<'de> de::MapAccess<'de> for NumberDeserializer {
+    type Error = PythonizeError;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        if self.number.is_none() {
+            return Ok(None);
+        }
+        seed.deserialize(TOKEN.into_deserializer()).map(Some)
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        seed.deserialize(self.number.take().unwrap().into_deserializer())
+    }
+}
+
 #[cfg(test)]
 mod test {
+    use std::{collections::HashMap, ffi::CStr};
+
     use super::*;
     use crate::error::ErrorImpl;
     use maplit::hashmap;
-    use pyo3::{IntoPy, Python};
+    use pyo3::{IntoPyObject, Python};
     use serde_json::{json, Value as JsonValue};
 
-    fn test_de<T>(code: &str, expected: &T, expected_json: &JsonValue)
+    fn test_de<T>(code: &CStr, expected: &T, expected_json: &JsonValue)
     where
         T: de::DeserializeOwned + PartialEq + std::fmt::Debug,
     {
-        Python::with_gil(|py| {
-            let obj = py.eval_bound(code, None, None).unwrap();
-            let actual: T = depythonize(&obj).unwrap();
-            assert_eq!(&actual, expected);
-            let actual_json: JsonValue = depythonize(&obj).unwrap();
-            assert_eq!(&actual_json, expected_json);
-
-            #[allow(deprecated)]
-            let actual: T = depythonize_bound(obj.clone()).unwrap();
-            assert_eq!(&actual, expected);
+        Python::attach(|py| {
+            let obj = py.eval(code, None, None).unwrap();
+            test_de_with_obj(&obj, expected, expected_json);
         });
     }
 
+    fn test_de_with_obj<T>(obj: &Bound<'_, PyAny>, expected: &T, expected_json: &JsonValue)
+    where
+        T: de::DeserializeOwned + PartialEq + std::fmt::Debug,
+    {
+        let actual: T = depythonize(obj).unwrap();
+        assert_eq!(&actual, expected);
+
+        let actual_json: JsonValue = depythonize(obj).unwrap();
+        assert_eq!(&actual_json, expected_json);
+    }
+
     #[test]
     fn test_empty_struct() {
         #[derive(Debug, Deserialize, PartialEq)]
@@ -554,7 +691,7 @@ mod test {
 
         let expected = Empty;
         let expected_json = json!(null);
-        let code = "None";
+        let code = c"None";
         test_de(code, &expected, &expected_json);
     }
 
@@ -580,7 +717,7 @@ mod test {
             "baz": 45.23,
             "qux": true
         });
-        let code = "{'foo': 'Foo', 'bar': 8, 'baz': 45.23, 'qux': True}";
+        let code = c"{'foo': 'Foo', 'bar': 8, 'baz': 45.23, 'qux': True}";
         test_de(code, &expected, &expected_json);
     }
 
@@ -592,13 +729,11 @@ mod test {
             bar: usize,
         }
 
-        let code = "{'foo': 'Foo'}";
+        let code = c"{'foo': 'Foo'}";
 
-        Python::with_gil(|py| {
-            let locals = PyDict::new_bound(py);
-            py.run_bound(&format!("obj = {}", code), None, Some(&locals))
-                .unwrap();
-            let obj = locals.get_item("obj").unwrap().unwrap();
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            let obj = py.eval(code, None, Some(&locals)).unwrap();
             assert!(matches!(
                 *depythonize::<Struct>(&obj).unwrap_err().inner,
                 ErrorImpl::Message(msg) if msg == "missing field `bar`"
@@ -613,7 +748,7 @@ mod test {
 
         let expected = TupleStruct("cat".to_string(), -10.05);
         let expected_json = json!(["cat", -10.05]);
-        let code = "('cat', -10.05)";
+        let code = c"('cat', -10.05)";
         test_de(code, &expected, &expected_json);
     }
 
@@ -622,13 +757,11 @@ mod test {
         #[derive(Debug, Deserialize, PartialEq)]
         struct TupleStruct(String, f64);
 
-        let code = "('cat', -10.05, 'foo')";
+        let code = c"('cat', -10.05, 'foo')";
 
-        Python::with_gil(|py| {
-            let locals = PyDict::new_bound(py);
-            py.run_bound(&format!("obj = {}", code), None, Some(&locals))
-                .unwrap();
-            let obj = locals.get_item("obj").unwrap().unwrap();
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            let obj = py.eval(code, None, Some(&locals)).unwrap();
             assert!(matches!(
                 *depythonize::<TupleStruct>(&obj).unwrap_err().inner,
                 ErrorImpl::IncorrectSequenceLength { expected, got } if expected == 2 && got == 3
@@ -643,7 +776,7 @@ mod test {
 
         let expected = TupleStruct("cat".to_string(), -10.05);
         let expected_json = json!(["cat", -10.05]);
-        let code = "['cat', -10.05]";
+        let code = c"['cat', -10.05]";
         test_de(code, &expected, &expected_json);
     }
 
@@ -651,7 +784,7 @@ mod test {
     fn test_tuple() {
         let expected = ("foo".to_string(), 5);
         let expected_json = json!(["foo", 5]);
-        let code = "('foo', 5)";
+        let code = c"('foo', 5)";
         test_de(code, &expected, &expected_json);
     }
 
@@ -659,7 +792,7 @@ mod test {
     fn test_tuple_from_pylist() {
         let expected = ("foo".to_string(), 5);
         let expected_json = json!(["foo", 5]);
-        let code = "['foo', 5]";
+        let code = c"['foo', 5]";
         test_de(code, &expected, &expected_json);
     }
 
@@ -667,7 +800,7 @@ mod test {
     fn test_vec_from_pyset() {
         let expected = vec!["foo".to_string()];
         let expected_json = json!(["foo"]);
-        let code = "{'foo'}";
+        let code = c"{'foo'}";
         test_de(code, &expected, &expected_json);
     }
 
@@ -675,7 +808,7 @@ mod test {
     fn test_vec_from_pyfrozenset() {
         let expected = vec!["foo".to_string()];
         let expected_json = json!(["foo"]);
-        let code = "frozenset({'foo'})";
+        let code = c"frozenset({'foo'})";
         test_de(code, &expected, &expected_json);
     }
 
@@ -683,7 +816,7 @@ mod test {
     fn test_vec() {
         let expected = vec![3, 2, 1];
         let expected_json = json!([3, 2, 1]);
-        let code = "[3, 2, 1]";
+        let code = c"[3, 2, 1]";
         test_de(code, &expected, &expected_json);
     }
 
@@ -691,7 +824,7 @@ mod test {
     fn test_vec_from_tuple() {
         let expected = vec![3, 2, 1];
         let expected_json = json!([3, 2, 1]);
-        let code = "(3, 2, 1)";
+        let code = c"(3, 2, 1)";
         test_de(code, &expected, &expected_json);
     }
 
@@ -699,7 +832,7 @@ mod test {
     fn test_hashmap() {
         let expected = hashmap! {"foo".to_string() => 4};
         let expected_json = json!({"foo": 4 });
-        let code = "{'foo': 4}";
+        let code = c"{'foo': 4}";
         test_de(code, &expected, &expected_json);
     }
 
@@ -712,7 +845,7 @@ mod test {
 
         let expected = Foo::Variant;
         let expected_json = json!("Variant");
-        let code = "'Variant'";
+        let code = c"'Variant'";
         test_de(code, &expected, &expected_json);
     }
 
@@ -725,7 +858,7 @@ mod test {
 
         let expected = Foo::Tuple(12, "cat".to_string());
         let expected_json = json!({"Tuple": [12, "cat"]});
-        let code = "{'Tuple': [12, 'cat']}";
+        let code = c"{'Tuple': [12, 'cat']}";
         test_de(code, &expected, &expected_json);
     }
 
@@ -738,7 +871,7 @@ mod test {
 
         let expected = Foo::NewType("cat".to_string());
         let expected_json = json!({"NewType": "cat" });
-        let code = "{'NewType': 'cat'}";
+        let code = c"{'NewType': 'cat'}";
         test_de(code, &expected, &expected_json);
     }
 
@@ -754,7 +887,7 @@ mod test {
             bar: 25,
         };
         let expected_json = json!({"Struct": {"foo": "cat", "bar": 25 }});
-        let code = "{'Struct': {'foo': 'cat', 'bar': 25}}";
+        let code = c"{'Struct': {'foo': 'cat', 'bar': 25}}";
         test_de(code, &expected, &expected_json);
     }
     #[test]
@@ -767,7 +900,7 @@ mod test {
 
         let expected = Foo::Tuple(12.0, 'c');
         let expected_json = json!([12.0, 'c']);
-        let code = "[12.0, 'c']";
+        let code = c"[12.0, 'c']";
         test_de(code, &expected, &expected_json);
     }
 
@@ -781,7 +914,7 @@ mod test {
 
         let expected = Foo::NewType("cat".to_string());
         let expected_json = json!("cat");
-        let code = "'cat'";
+        let code = c"'cat'";
         test_de(code, &expected, &expected_json);
     }
 
@@ -798,7 +931,7 @@ mod test {
             bar: [2, 5, 3, 1],
         };
         let expected_json = json!({"foo": ["a", "b", "c"], "bar": [2, 5, 3, 1]});
-        let code = "{'foo': ['a', 'b', 'c'], 'bar': [2, 5, 3, 1]}";
+        let code = c"{'foo': ['a', 'b', 'c'], 'bar': [2, 5, 3, 1]}";
         test_de(code, &expected, &expected_json);
     }
 
@@ -831,46 +964,46 @@ mod test {
         };
         let expected_json =
             json!({"name": "SomeFoo", "bar": { "value": 13, "variant": { "Tuple": [-1.5, 8]}}});
-        let code = "{'name': 'SomeFoo', 'bar': {'value': 13, 'variant': {'Tuple': [-1.5, 8]}}}";
+        let code = c"{'name': 'SomeFoo', 'bar': {'value': 13, 'variant': {'Tuple': [-1.5, 8]}}}";
         test_de(code, &expected, &expected_json);
     }
 
     #[test]
     fn test_int_limits() {
-        Python::with_gil(|py| {
-            // serde_json::Value supports u64 and i64 as maxiumum sizes
-            let _: serde_json::Value = depythonize(&u8::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&u8::MIN.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i8::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i8::MIN.into_py(py).into_bound(py)).unwrap();
-
-            let _: serde_json::Value = depythonize(&u16::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&u16::MIN.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i16::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i16::MIN.into_py(py).into_bound(py)).unwrap();
-
-            let _: serde_json::Value = depythonize(&u32::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&u32::MIN.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i32::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i32::MIN.into_py(py).into_bound(py)).unwrap();
-
-            let _: serde_json::Value = depythonize(&u64::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&u64::MIN.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i64::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: serde_json::Value = depythonize(&i64::MIN.into_py(py).into_bound(py)).unwrap();
-
-            let _: u128 = depythonize(&u128::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: i128 = depythonize(&u128::MIN.into_py(py).into_bound(py)).unwrap();
-
-            let _: i128 = depythonize(&i128::MAX.into_py(py).into_bound(py)).unwrap();
-            let _: i128 = depythonize(&i128::MIN.into_py(py).into_bound(py)).unwrap();
+        Python::attach(|py| {
+            // serde_json::Value supports u64 and i64 as maximum sizes
+            let _: serde_json::Value = depythonize(&u8::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&u8::MIN.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i8::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i8::MIN.into_pyobject(py).unwrap()).unwrap();
+
+            let _: serde_json::Value = depythonize(&u16::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&u16::MIN.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i16::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i16::MIN.into_pyobject(py).unwrap()).unwrap();
+
+            let _: serde_json::Value = depythonize(&u32::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&u32::MIN.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i32::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i32::MIN.into_pyobject(py).unwrap()).unwrap();
+
+            let _: serde_json::Value = depythonize(&u64::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&u64::MIN.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i64::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: serde_json::Value = depythonize(&i64::MIN.into_pyobject(py).unwrap()).unwrap();
+
+            let _: u128 = depythonize(&u128::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: i128 = depythonize(&u128::MIN.into_pyobject(py).unwrap()).unwrap();
+
+            let _: i128 = depythonize(&i128::MAX.into_pyobject(py).unwrap()).unwrap();
+            let _: i128 = depythonize(&i128::MIN.into_pyobject(py).unwrap()).unwrap();
         });
     }
 
     #[test]
     fn test_deserialize_bytes() {
-        Python::with_gil(|py| {
-            let obj = PyBytes::new_bound(py, "hello".as_bytes());
+        Python::attach(|py| {
+            let obj = PyBytes::new(py, "hello".as_bytes());
             let actual: Vec<u8> = depythonize(&obj).unwrap();
             assert_eq!(actual, b"hello");
         })
@@ -880,15 +1013,28 @@ mod test {
     fn test_char() {
         let expected = 'a';
         let expected_json = json!("a");
-        let code = "'a'";
+        let code = c"'a'";
         test_de(code, &expected, &expected_json);
     }
 
+    #[test]
+    fn test_char_multibyte_codepoint() {
+        // 'ä' is U+00E4: one Unicode codepoint, two UTF-8 bytes.
+        // Previously, deserialize_char checked s.len() (byte length) != 1,
+        // which incorrectly rejected any non-ASCII char. The fix checks
+        // s.chars().count() (codepoint count) != 1 instead.
+        Python::attach(|py| {
+            let py_str = pyo3::types::PyString::new(py, "ä");
+            let result = depythonize::<char>(py_str.as_any());
+            assert_eq!(result.unwrap(), 'ä');
+        });
+    }
+
     #[test]
     fn test_unknown_type() {
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             let obj = py
-                .import_bound("decimal")
+                .import("decimal")
                 .unwrap()
                 .getattr("Decimal")
                 .unwrap()
@@ -901,4 +1047,101 @@ mod test {
             ));
         });
     }
+
+    #[test]
+    fn test_dataclass() {
+        let code = c"\
+from dataclasses import dataclass
+
+@dataclass
+class Point:
+    x: int
+    y: int
+
+point = Point(1, 2)";
+
+        #[derive(Debug, Deserialize, PartialEq)]
+        struct Point {
+            x: i32,
+            y: i32,
+        }
+
+        let expected = Point { x: 1, y: 2 };
+        let expected_json = json!({"x": 1, "y": 2});
+
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(&locals)).unwrap();
+            let obj = locals.get_item("point").unwrap().unwrap();
+            test_de_with_obj(&obj, &expected, &expected_json);
+
+            let map: HashMap<String, i32> = depythonize(&obj).unwrap();
+            assert_eq!(map.len(), 2);
+            assert_eq!(*map.get("x").unwrap(), 1);
+            assert_eq!(*map.get("y").unwrap(), 2);
+        });
+    }
+
+    #[test]
+    fn test_dataclass_missing_field() {
+        let code = c"\
+from dataclasses import dataclass
+
+@dataclass
+class Point:
+    x: int
+    y: int
+
+point = Point(1, 2)";
+
+        #[derive(Debug, Deserialize, PartialEq)]
+        struct Point {
+            x: i32,
+            y: i32,
+            z: i32,
+        }
+
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(&locals)).unwrap();
+            let obj = locals.get_item("point").unwrap().unwrap();
+            let err = depythonize::<Point>(&obj).unwrap_err();
+            assert!(matches!(
+                *err.inner,
+                ErrorImpl::Message(msg) if msg == "missing field `z`"
+            ));
+        });
+    }
+
+    #[test]
+    fn test_dataclass_extra_field() {
+        let code = c"\
+from dataclasses import dataclass
+
+@dataclass
+class Point:
+    x: int
+    y: int
+    z: int
+
+point = Point(1, 2, 3)";
+
+        #[derive(Debug, Deserialize, PartialEq)]
+        #[serde(deny_unknown_fields)]
+        struct Point {
+            x: i32,
+            y: i32,
+        }
+
+        Python::attach(|py| {
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(&locals)).unwrap();
+            let obj = locals.get_item("point").unwrap().unwrap();
+            let err = depythonize::<Point>(&obj).unwrap_err();
+            assert!(matches!(
+                *err.inner,
+                ErrorImpl::Message(msg) if msg == "unknown field `z`, expected `x` or `y`"
+            ));
+        });
+    }
 }
diff --git a/src/error.rs b/src/error.rs
index 4aee7ea..b608106 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,6 +1,7 @@
 use pyo3::PyErr;
-use pyo3::{exceptions::*, DowncastError, DowncastIntoError};
+use pyo3::{exceptions::*, CastError, CastIntoError};
 use serde::{de, ser};
+use std::convert::Infallible;
 use std::error;
 use std::fmt::{self, Debug, Display};
 use std::result;
@@ -72,7 +73,7 @@ pub enum ErrorImpl {
     Message(String),
     /// A Python type not supported by the deserializer
     UnsupportedType(String),
-    /// A `PyAny` object that failed to downcast to an expected Python type
+    /// A `PyAny` object that failed to cast to an expected Python type
     UnexpectedType(String),
     /// Dict keys should be strings to deserialize to struct fields
     DictKeyNotString,
@@ -136,6 +137,13 @@ impl de::Error for PythonizeError {
     }
 }
 
+/// Convert an exception raised in Python to a `PythonizeError`
+impl From<Infallible> for PythonizeError {
+    fn from(other: Infallible) -> Self {
+        match other {}
+    }
+}
+
 /// Convert an exception raised in Python to a `PythonizeError`
 impl From<PyErr> for PythonizeError {
     fn from(other: PyErr) -> Self {
@@ -145,18 +153,18 @@ impl From<PyErr> for PythonizeError {
     }
 }
 
-/// Handle errors that occur when attempting to use `PyAny::cast_as`
-impl<'a, 'py> From<DowncastError<'a, 'py>> for PythonizeError {
-    fn from(other: DowncastError<'a, 'py>) -> Self {
+/// Handle errors that occur when attempting to use `PyAny::cast`
+impl<'a, 'py> From<CastError<'a, 'py>> for PythonizeError {
+    fn from(other: CastError<'a, 'py>) -> Self {
         Self {
             inner: Box::new(ErrorImpl::UnexpectedType(other.to_string())),
         }
     }
 }
 
-/// Handle errors that occur when attempting to use `PyAny::cast_as`
-impl<'py> From<DowncastIntoError<'py>> for PythonizeError {
-    fn from(other: DowncastIntoError<'py>) -> Self {
+/// Handle errors that occur when attempting to use `PyAny::cast`
+impl<'py> From<CastIntoError<'py>> for PythonizeError {
+    fn from(other: CastIntoError<'py>) -> Self {
         Self {
             inner: Box::new(ErrorImpl::UnexpectedType(other.to_string())),
         }
diff --git a/src/lib.rs b/src/lib.rs
index 186fdf6..e625b6f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,8 +4,6 @@ mod de;
 mod error;
 mod ser;
 
-#[allow(deprecated)]
-pub use crate::de::depythonize_bound;
 pub use crate::de::{depythonize, Depythonizer};
 pub use crate::error::{PythonizeError, Result};
 pub use crate::ser::{
diff --git a/src/ser.rs b/src/ser.rs
index 072212e..02f3caf 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,93 +1,96 @@
 use std::marker::PhantomData;
 
+#[cfg(feature = "arbitrary_precision")]
+use pyo3::types::{PyAnyMethods, PyFloat, PyInt};
 use pyo3::types::{
-    PyAnyMethods, PyDict, PyDictMethods, PyList, PyMapping, PySequence, PyString, PyTuple,
+    PyDict, PyDictMethods, PyList, PyListMethods, PyMapping, PySequence, PyString, PyTuple,
     PyTupleMethods,
 };
-use pyo3::{Bound, IntoPy, PyAny, PyResult, Python, ToPyObject};
+use pyo3::{Bound, IntoPyObject, IntoPyObjectExt, PyAny, PyResult, Python};
 use serde::{ser, Serialize};
 
 use crate::error::{PythonizeError, Result};
 
-// TODO: move 'py lifetime into builder once GATs are available in MSRV
 /// Trait for types which can represent a Python mapping
-pub trait PythonizeMappingType<'py> {
+pub trait PythonizeMappingType {
     /// Builder type for Python mappings
-    type Builder;
+    type Builder<'py>: 'py;
 
     /// Create a builder for a Python mapping
-    fn builder(py: Python<'py>, len: Option<usize>) -> PyResult<Self::Builder>;
+    fn builder<'py>(py: Python<'py>, len: Option<usize>) -> PyResult<Self::Builder<'py>>;
 
     /// Adds the key-value item to the mapping being built
-    fn push_item(
-        builder: &mut Self::Builder,
+    fn push_item<'py>(
+        builder: &mut Self::Builder<'py>,
         key: Bound<'py, PyAny>,
         value: Bound<'py, PyAny>,
     ) -> PyResult<()>;
 
     /// Build the Python mapping
-    fn finish(builder: Self::Builder) -> PyResult<Bound<'py, PyMapping>>;
+    fn finish<'py>(builder: Self::Builder<'py>) -> PyResult<Bound<'py, PyMapping>>;
 }
 
-// TODO: move 'py lifetime into builder once GATs are available in MSRV
 /// Trait for types which can represent a Python mapping and have a name
-pub trait PythonizeNamedMappingType<'py> {
+pub trait PythonizeNamedMappingType {
     /// Builder type for Python mappings with a name
-    type Builder;
+    type Builder<'py>: 'py;
 
     /// Create a builder for a Python mapping with a name
-    fn builder(py: Python<'py>, len: usize, name: &'static str) -> PyResult<Self::Builder>;
+    fn builder<'py>(
+        py: Python<'py>,
+        len: usize,
+        name: &'static str,
+    ) -> PyResult<Self::Builder<'py>>;
 
     /// Adds the field to the named mapping being built
-    fn push_field(
-        builder: &mut Self::Builder,
+    fn push_field<'py>(
+        builder: &mut Self::Builder<'py>,
         name: Bound<'py, PyString>,
         value: Bound<'py, PyAny>,
     ) -> PyResult<()>;
 
     /// Build the Python mapping
-    fn finish(builder: Self::Builder) -> PyResult<Bound<'py, PyMapping>>;
+    fn finish<'py>(builder: Self::Builder<'py>) -> PyResult<Bound<'py, PyMapping>>;
 }
 
 /// Trait for types which can represent a Python sequence
 pub trait PythonizeListType: Sized {
     /// Constructor
-    fn create_sequence<T, U>(
-        py: Python,
+    fn create_sequence<'py, T, U>(
+        py: Python<'py>,
         elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> PyResult<Bound<PySequence>>
+    ) -> PyResult<Bound<'py, PySequence>>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
         U: ExactSizeIterator<Item = T>;
 }
 
-// TODO: remove 'py lifetime once GATs are available in MSRV
 /// Custom types for serialization
-pub trait PythonizeTypes<'py> {
+pub trait PythonizeTypes {
     /// Python map type (should be representable as python mapping)
-    type Map: PythonizeMappingType<'py>;
+    type Map: PythonizeMappingType;
     /// Python (struct-like) named map type (should be representable as python mapping)
-    type NamedMap: PythonizeNamedMappingType<'py>;
+    type NamedMap: PythonizeNamedMappingType;
     /// Python sequence type (should be representable as python sequence)
     type List: PythonizeListType;
 }
 
-impl<'py> PythonizeMappingType<'py> for PyDict {
-    type Builder = Bound<'py, Self>;
+impl PythonizeMappingType for PyDict {
+    type Builder<'py> = Bound<'py, Self>;
 
-    fn builder(py: Python<'py>, _len: Option<usize>) -> PyResult<Self::Builder> {
-        Ok(Self::new_bound(py))
+    fn builder<'py>(py: Python<'py>, _len: Option<usize>) -> PyResult<Self::Builder<'py>> {
+        Ok(Self::new(py))
     }
 
-    fn push_item(
-        builder: &mut Self::Builder,
+    fn push_item<'py>(
+        builder: &mut Self::Builder<'py>,
         key: Bound<'py, PyAny>,
         value: Bound<'py, PyAny>,
     ) -> PyResult<()> {
         builder.set_item(key, value)
     }
 
-    fn finish(builder: Self::Builder) -> PyResult<Bound<'py, PyMapping>> {
+    fn finish<'py>(builder: Self::Builder<'py>) -> PyResult<Bound<'py, PyMapping>> {
         Ok(builder.into_mapping())
     }
 }
@@ -99,67 +102,65 @@ impl<'py> PythonizeMappingType<'py> for PyDict {
 /// This adapter is commonly applied to use the same unnamed mapping type for
 /// both [`PythonizeTypes::Map`] and [`PythonizeTypes::NamedMap`] while only
 /// implementing [`PythonizeMappingType`].
-pub struct PythonizeUnnamedMappingAdapter<'py, T: PythonizeMappingType<'py>> {
+pub struct PythonizeUnnamedMappingAdapter<T: PythonizeMappingType> {
     _unnamed: T,
-    _marker: PhantomData<&'py ()>,
 }
 
-impl<'py, T: PythonizeMappingType<'py>> PythonizeNamedMappingType<'py>
-    for PythonizeUnnamedMappingAdapter<'py, T>
-{
-    type Builder = <T as PythonizeMappingType<'py>>::Builder;
+impl<T: PythonizeMappingType> PythonizeNamedMappingType for PythonizeUnnamedMappingAdapter<T> {
+    type Builder<'py> = T::Builder<'py>;
 
-    fn builder(py: Python<'py>, len: usize, _name: &'static str) -> PyResult<Self::Builder> {
-        <T as PythonizeMappingType>::builder(py, Some(len))
+    fn builder<'py>(
+        py: Python<'py>,
+        len: usize,
+        _name: &'static str,
+    ) -> PyResult<Self::Builder<'py>> {
+        T::builder(py, Some(len))
     }
 
-    fn push_field(
-        builder: &mut Self::Builder,
+    fn push_field<'py>(
+        builder: &mut Self::Builder<'py>,
         name: Bound<'py, PyString>,
         value: Bound<'py, PyAny>,
     ) -> PyResult<()> {
-        <T as PythonizeMappingType>::push_item(builder, name.into_any(), value)
+        T::push_item(builder, name.into_any(), value)
     }
 
-    fn finish(builder: Self::Builder) -> PyResult<Bound<'py, PyMapping>> {
-        <T as PythonizeMappingType>::finish(builder)
+    fn finish<'py>(builder: Self::Builder<'py>) -> PyResult<Bound<'py, PyMapping>> {
+        T::finish(builder)
     }
 }
 
 impl PythonizeListType for PyList {
-    fn create_sequence<T, U>(
-        py: Python,
+    fn create_sequence<'py, T, U>(
+        py: Python<'py>,
         elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> PyResult<Bound<PySequence>>
+    ) -> PyResult<Bound<'py, PySequence>>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
         U: ExactSizeIterator<Item = T>,
     {
-        Ok(PyList::new_bound(py, elements)
-            .into_any()
-            .downcast_into()
-            .unwrap())
+        Ok(PyList::new(py, elements)?.into_sequence())
     }
 }
 
 impl PythonizeListType for PyTuple {
-    fn create_sequence<T, U>(
-        py: Python,
+    fn create_sequence<'py, T, U>(
+        py: Python<'py>,
         elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> PyResult<Bound<PySequence>>
+    ) -> PyResult<Bound<'py, PySequence>>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
         U: ExactSizeIterator<Item = T>,
     {
-        Ok(PyTuple::new_bound(py, elements).into_sequence())
+        Ok(PyTuple::new(py, elements)?.into_sequence())
     }
 }
 
 pub struct PythonizeDefault;
 
-impl<'py> PythonizeTypes<'py> for PythonizeDefault {
+impl PythonizeTypes for PythonizeDefault {
     type Map = PyDict;
-    type NamedMap = PythonizeUnnamedMappingAdapter<'py, PyDict>;
+    type NamedMap = PythonizeUnnamedMappingAdapter<PyDict>;
     type List = PyList;
 }
 
@@ -176,7 +177,7 @@ where
 pub fn pythonize_custom<'py, P, T>(py: Python<'py>, value: &T) -> Result<Bound<'py, PyAny>>
 where
     T: ?Sized + Serialize,
-    P: PythonizeTypes<'py>,
+    P: PythonizeTypes,
 {
     value.serialize(Pythonizer::custom::<P>(py))
 }
@@ -224,28 +225,54 @@ pub struct PythonTupleVariantSerializer<'py, P> {
 }
 
 #[doc(hidden)]
-pub struct PythonStructVariantSerializer<'py, P: PythonizeTypes<'py>> {
+pub struct PythonStructVariantSerializer<'py, P: PythonizeTypes> {
     name: &'static str,
     variant: &'static str,
     inner: PythonStructDictSerializer<'py, P>,
 }
 
+#[cfg(feature = "arbitrary_precision")]
 #[doc(hidden)]
-pub struct PythonStructDictSerializer<'py, P: PythonizeTypes<'py>> {
+pub enum StructSerializer<'py, P: PythonizeTypes> {
+    Struct(PythonStructDictSerializer<'py, P>),
+    Number {
+        py: Python<'py>,
+        number_string: Option<String>,
+        _types: PhantomData<P>,
+    },
+}
+
+#[cfg(not(feature = "arbitrary_precision"))]
+#[doc(hidden)]
+pub type StructSerializer<'py, P> = PythonStructDictSerializer<'py, P>;
+
+#[doc(hidden)]
+pub struct PythonStructDictSerializer<'py, P: PythonizeTypes> {
     py: Python<'py>,
-    builder: <P::NamedMap as PythonizeNamedMappingType<'py>>::Builder,
+    builder: <P::NamedMap as PythonizeNamedMappingType>::Builder<'py>,
     _types: PhantomData<P>,
 }
 
 #[doc(hidden)]
-pub struct PythonMapSerializer<'py, P: PythonizeTypes<'py>> {
+pub struct PythonMapSerializer<'py, P: PythonizeTypes> {
     py: Python<'py>,
-    builder: <P::Map as PythonizeMappingType<'py>>::Builder,
+    builder: <P::Map as PythonizeMappingType>::Builder<'py>,
     key: Option<Bound<'py, PyAny>>,
     _types: PhantomData<P>,
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::Serializer for Pythonizer<'py, P> {
+impl<'py, P: PythonizeTypes> Pythonizer<'py, P> {
+    /// The default implementation for serialisation functions.
+    #[inline]
+    fn serialise_default<T>(self, v: T) -> Result<Bound<'py, PyAny>>
+    where
+        T: IntoPyObject<'py>,
+    {
+        v.into_bound_py_any(self.py).map_err(Into::into)
+    }
+}
+
+impl<'py, P: PythonizeTypes> ser::Serializer for Pythonizer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
     type SerializeSeq = PythonCollectionSerializer<'py, P>;
@@ -253,51 +280,59 @@ impl<'py, P: PythonizeTypes<'py>> ser::Serializer for Pythonizer<'py, P> {
     type SerializeTupleStruct = PythonCollectionSerializer<'py, P>;
     type SerializeTupleVariant = PythonTupleVariantSerializer<'py, P>;
     type SerializeMap = PythonMapSerializer<'py, P>;
-    type SerializeStruct = PythonStructDictSerializer<'py, P>;
+    type SerializeStruct = StructSerializer<'py, P>;
     type SerializeStructVariant = PythonStructVariantSerializer<'py, P>;
 
     fn serialize_bool(self, v: bool) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_i8(self, v: i8) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_i16(self, v: i16) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_i32(self, v: i32) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_i64(self, v: i64) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
+    }
+
+    fn serialize_i128(self, v: i128) -> Result<Bound<'py, PyAny>> {
+        self.serialise_default(v)
     }
 
     fn serialize_u8(self, v: u8) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_u16(self, v: u16) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_u32(self, v: u32) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_u64(self, v: u64) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
+    }
+
+    fn serialize_u128(self, v: u128) -> Result<Bound<'py, PyAny>> {
+        self.serialise_default(v)
     }
 
     fn serialize_f32(self, v: f32) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_f64(self, v: f64) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_char(self, v: char) -> Result<Bound<'py, PyAny>> {
@@ -305,11 +340,11 @@ impl<'py, P: PythonizeTypes<'py>> ser::Serializer for Pythonizer<'py, P> {
     }
 
     fn serialize_str(self, v: &str) -> Result<Bound<'py, PyAny>> {
-        Ok(PyString::new_bound(self.py, v).into_any())
+        Ok(PyString::new(self.py, v).into_any())
     }
 
     fn serialize_bytes(self, v: &[u8]) -> Result<Bound<'py, PyAny>> {
-        Ok(v.into_py(self.py).into_bound(self.py))
+        self.serialise_default(v)
     }
 
     fn serialize_none(self) -> Result<Bound<'py, PyAny>> {
@@ -364,7 +399,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::Serializer for Pythonizer<'py, P> {
         let mut m = P::NamedMap::builder(self.py, 1, name)?;
         P::NamedMap::push_field(
             &mut m,
-            PyString::new_bound(self.py, variant),
+            PyString::new(self.py, variant),
             value.serialize(self)?,
         )?;
         Ok(P::NamedMap::finish(m)?.into_any())
@@ -422,16 +457,34 @@ impl<'py, P: PythonizeTypes<'py>> ser::Serializer for Pythonizer<'py, P> {
         })
     }
 
-    fn serialize_struct(
-        self,
-        name: &'static str,
-        len: usize,
-    ) -> Result<PythonStructDictSerializer<'py, P>> {
-        Ok(PythonStructDictSerializer {
-            py: self.py,
-            builder: P::NamedMap::builder(self.py, len, name)?,
-            _types: PhantomData,
-        })
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<StructSerializer<'py, P>> {
+        #[cfg(feature = "arbitrary_precision")]
+        {
+            // With arbitrary_precision enabled, a serde_json::Number serializes as a "$serde_json::private::Number"
+            // struct with a "$serde_json::private::Number" field, whose value is the String in Number::n.
+            if name == "$serde_json::private::Number" && len == 1 {
+                return Ok(StructSerializer::Number {
+                    py: self.py,
+                    number_string: None,
+                    _types: PhantomData,
+                });
+            }
+
+            Ok(StructSerializer::Struct(PythonStructDictSerializer {
+                py: self.py,
+                builder: P::NamedMap::builder(self.py, len, name)?,
+                _types: PhantomData,
+            }))
+        }
+
+        #[cfg(not(feature = "arbitrary_precision"))]
+        {
+            Ok(PythonStructDictSerializer {
+                py: self.py,
+                builder: P::NamedMap::builder(self.py, len, name)?,
+                _types: PhantomData,
+            })
+        }
     }
 
     fn serialize_struct_variant(
@@ -453,7 +506,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::Serializer for Pythonizer<'py, P> {
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeSeq for PythonCollectionSerializer<'py, P> {
+impl<'py, P: PythonizeTypes> ser::SerializeSeq for PythonCollectionSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -467,11 +520,11 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeSeq for PythonCollectionSerializ
 
     fn end(self) -> Result<Bound<'py, PyAny>> {
         let instance = P::List::create_sequence(self.py, self.items)?;
-        Ok(instance.to_object(self.py).into_bound(self.py))
+        Ok(instance.into_pyobject(self.py)?.into_any())
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeTuple for PythonCollectionSerializer<'py, P> {
+impl<'py, P: PythonizeTypes> ser::SerializeTuple for PythonCollectionSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -483,11 +536,11 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeTuple for PythonCollectionSerial
     }
 
     fn end(self) -> Result<Bound<'py, PyAny>> {
-        Ok(PyTuple::new_bound(self.py, self.items).into_any())
+        Ok(PyTuple::new(self.py, self.items)?.into_any())
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeTupleStruct for PythonCollectionSerializer<'py, P> {
+impl<'py, P: PythonizeTypes> ser::SerializeTupleStruct for PythonCollectionSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -503,9 +556,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeTupleStruct for PythonCollection
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeTupleVariant
-    for PythonTupleVariantSerializer<'py, P>
-{
+impl<'py, P: PythonizeTypes> ser::SerializeTupleVariant for PythonTupleVariantSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -520,14 +571,14 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeTupleVariant
         let mut m = P::NamedMap::builder(self.inner.py, 1, self.name)?;
         P::NamedMap::push_field(
             &mut m,
-            PyString::new_bound(self.inner.py, self.variant),
+            PyString::new(self.inner.py, self.variant),
             ser::SerializeTuple::end(self.inner)?,
         )?;
         Ok(P::NamedMap::finish(m)?.into_any())
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeMap for PythonMapSerializer<'py, P> {
+impl<'py, P: PythonizeTypes> ser::SerializeMap for PythonMapSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -558,7 +609,63 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeMap for PythonMapSerializer<'py,
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeStruct for PythonStructDictSerializer<'py, P> {
+#[cfg(feature = "arbitrary_precision")]
+impl<'py, P: PythonizeTypes> ser::SerializeStruct for StructSerializer<'py, P> {
+    type Ok = Bound<'py, PyAny>;
+    type Error = PythonizeError;
+
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match self {
+            StructSerializer::Struct(s) => s.serialize_field(key, value),
+            StructSerializer::Number { number_string, .. } => {
+                let serde_json::Value::String(s) = value
+                    .serialize(serde_json::value::Serializer)
+                    .map_err(|e| {
+                    PythonizeError::msg(format!("Failed to serialize number: {}", e))
+                })?
+                else {
+                    return Err(PythonizeError::msg("Expected string in serde_json::Number"));
+                };
+
+                *number_string = Some(s);
+                Ok(())
+            }
+        }
+    }
+
+    fn end(self) -> Result<Bound<'py, PyAny>> {
+        match self {
+            StructSerializer::Struct(s) => s.end(),
+            StructSerializer::Number {
+                py,
+                number_string: Some(s),
+                ..
+            } => {
+                if let Ok(i) = s.parse::<i64>() {
+                    return Ok(PyInt::new(py, i).into_any());
+                }
+                if let Ok(u) = s.parse::<u64>() {
+                    return Ok(PyInt::new(py, u).into_any());
+                }
+                if s.chars().any(|c| c == '.' || c == 'e' || c == 'E') {
+                    if let Ok(f) = s.parse::<f64>() {
+                        return Ok(PyFloat::new(py, f).into_any());
+                    }
+                }
+                // Fall back to Python's int() constructor, which supports arbitrary precision.
+                py.get_type::<PyInt>()
+                    .call1((s.as_str(),))
+                    .map_err(|e| PythonizeError::msg(format!("Invalid number: {}", e)))
+            }
+            StructSerializer::Number { .. } => Err(PythonizeError::msg("Empty serde_json::Number")),
+        }
+    }
+}
+
+impl<'py, P: PythonizeTypes> ser::SerializeStruct for PythonStructDictSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -568,7 +675,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeStruct for PythonStructDictSeria
     {
         P::NamedMap::push_field(
             &mut self.builder,
-            PyString::new_bound(self.py, key),
+            PyString::new(self.py, key),
             pythonize_custom::<P, _>(self.py, value)?,
         )?;
         Ok(())
@@ -579,9 +686,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeStruct for PythonStructDictSeria
     }
 }
 
-impl<'py, P: PythonizeTypes<'py>> ser::SerializeStructVariant
-    for PythonStructVariantSerializer<'py, P>
-{
+impl<'py, P: PythonizeTypes> ser::SerializeStructVariant for PythonStructVariantSerializer<'py, P> {
     type Ok = Bound<'py, PyAny>;
     type Error = PythonizeError;
 
@@ -591,7 +696,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeStructVariant
     {
         P::NamedMap::push_field(
             &mut self.inner.builder,
-            PyString::new_bound(self.inner.py, key),
+            PyString::new(self.inner.py, key),
             pythonize_custom::<P, _>(self.inner.py, value)?,
         )?;
         Ok(())
@@ -602,7 +707,7 @@ impl<'py, P: PythonizeTypes<'py>> ser::SerializeStructVariant
         let mut m = P::NamedMap::builder(self.inner.py, 1, self.name)?;
         P::NamedMap::push_field(
             &mut m,
-            PyString::new_bound(self.inner.py, self.variant),
+            PyString::new(self.inner.py, self.variant),
             v.into_any(),
         )?;
         Ok(P::NamedMap::finish(m)?.into_any())
@@ -622,14 +727,14 @@ mod test {
     where
         T: Serialize,
     {
-        Python::with_gil(|py| -> PyResult<()> {
+        Python::attach(|py| -> PyResult<()> {
             let obj = pythonize(py, &src)?;
 
-            let locals = PyDict::new_bound(py);
+            let locals = PyDict::new(py);
             locals.set_item("obj", obj)?;
 
-            py.run_bound(
-                "import json; result = json.dumps(obj, separators=(',', ':'))",
+            py.run(
+                c"import json; result = json.dumps(obj, separators=(',', ':'))",
                 None,
                 Some(&locals),
             )?;
@@ -774,6 +879,8 @@ mod test {
             f: u16,
             g: u32,
             h: u64,
+            i: i128,
+            j: u128,
         }
 
         test_ser(
@@ -786,8 +893,10 @@ mod test {
                 f: 6,
                 g: 7,
                 h: 8,
+                i: 9,
+                j: 10,
             },
-            r#"{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8}"#,
+            r#"{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9,"j":10}"#,
         )
     }
 
@@ -835,10 +944,10 @@ mod test {
         // serde treats &[u8] as a sequence of integers due to lack of specialization
         test_ser(b"foo", "[102,111,111]");
 
-        Python::with_gil(|py| {
+        Python::attach(|py| {
             assert!(pythonize(py, serde_bytes::Bytes::new(b"foo"))
                 .expect("bytes will always serialize successfully")
-                .eq(&PyBytes::new_bound(py, b"foo"))
+                .eq(&PyBytes::new(py, b"foo"))
                 .expect("bytes will always compare successfully"));
         });
     }
diff --git a/tests/test_arbitrary_precision.rs b/tests/test_arbitrary_precision.rs
new file mode 100644
index 0000000..dc5b38f
--- /dev/null
+++ b/tests/test_arbitrary_precision.rs
@@ -0,0 +1,108 @@
+#![cfg(feature = "arbitrary_precision")]
+
+use pyo3::prelude::*;
+use pythonize::{depythonize, pythonize};
+use serde_json::Value;
+
+#[test]
+fn test_greater_than_u64_max() {
+    Python::attach(|py| {
+        let json_str = r#"18446744073709551616"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+        let result = pythonize(py, &value).unwrap();
+        let number_str = result.str().unwrap().to_string();
+
+        assert!(result.is_instance_of::<pyo3::types::PyInt>());
+        assert_eq!(number_str, "18446744073709551616");
+    });
+}
+
+#[test]
+fn test_less_than_i64_min() {
+    Python::attach(|py| {
+        let json_str = r#"-9223372036854775809"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+        let result = pythonize(py, &value).unwrap();
+        let number_str = result.str().unwrap().to_string();
+
+        assert!(result.is_instance_of::<pyo3::types::PyInt>());
+        assert_eq!(number_str, "-9223372036854775809");
+    });
+}
+
+#[test]
+fn test_float() {
+    Python::attach(|py| {
+        let json_str = r#"3.141592653589793238"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+        let result = pythonize(py, &value).unwrap();
+        let num: f32 = result.extract().unwrap();
+
+        assert!(result.is_instance_of::<pyo3::types::PyFloat>());
+        assert_eq!(num, 3.141592653589793238); // not {'$serde_json::private::Number': ...}
+    });
+}
+
+#[test]
+fn test_int() {
+    Python::attach(|py| {
+        let json_str = r#"2"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+        let result = pythonize(py, &value).unwrap();
+        let num: i32 = result.extract().unwrap();
+
+        assert!(result.is_instance_of::<pyo3::types::PyInt>());
+        assert_eq!(num, 2); // not {'$serde_json::private::Number': '2'}
+    });
+}
+
+#[test]
+fn test_serde_error_if_token_empty() {
+    let json_str = r#"{"$serde_json::private::Number": ""}"#;
+    let result: Result<Value, _> = serde_json::from_str(json_str);
+
+    assert!(result.is_err());
+    assert!(result
+        .unwrap_err()
+        .to_string()
+        .contains("EOF while parsing a value"));
+}
+
+#[test]
+fn test_serde_error_if_token_invalid() {
+    let json_str = r#"{"$serde_json::private::Number": 2}"#;
+    let result: Result<Value, _> = serde_json::from_str(json_str);
+
+    assert!(result.is_err());
+    assert!(result
+        .unwrap_err()
+        .to_string()
+        .contains("invalid type: integer `2`, expected string containing a number"));
+}
+
+#[test]
+fn test_token_valid() {
+    Python::attach(|py| {
+        let json_str = r#"{"$serde_json::private::Number": "2"}"#;
+        let value: Value = serde_json::from_str(json_str).unwrap();
+        let result = pythonize(py, &value).unwrap();
+        let num: i32 = result.extract().unwrap();
+
+        assert!(result.is_instance_of::<pyo3::types::PyInt>());
+        assert_eq!(num, 2);
+    });
+}
+
+#[test]
+fn test_depythonize_greater_than_u128_max() {
+    Python::attach(|py| {
+        // u128::MAX + 1
+        let py_int = py
+            .eval(c"340282366920938463463374607431768211456", None, None)
+            .unwrap();
+        let value: Value = depythonize(&py_int).unwrap();
+
+        assert!(value.is_number());
+        assert_eq!(value.to_string(), "340282366920938463463374607431768211456");
+    });
+}
diff --git a/tests/test_collections.rs b/tests/test_collections.rs
new file mode 100644
index 0000000..9cd7164
--- /dev/null
+++ b/tests/test_collections.rs
@@ -0,0 +1,203 @@
+use std::collections::{BTreeMap, HashMap};
+
+use maplit::{btreemap, hashmap};
+use pyo3::prelude::*;
+use pythonize::{depythonize, pythonize};
+
+fn round_trip<T>(py: Python<'_>, val: T) -> T
+where
+    T: serde::Serialize + serde::de::DeserializeOwned + std::fmt::Debug + PartialEq,
+{
+    let py_val = pythonize(py, &val).expect("pythonize failed");
+    depythonize(&py_val).expect("depythonize failed")
+}
+
+// --- Vec<i32> ---
+
+#[test]
+fn test_vec_i32_empty() {
+    Python::attach(|py| {
+        let result = round_trip(py, Vec::<i32>::new());
+        assert_eq!(result, Vec::<i32>::new());
+    });
+}
+
+#[test]
+fn test_vec_i32_single() {
+    Python::attach(|py| {
+        assert_eq!(round_trip(py, vec![42i32]), vec![42i32]);
+    });
+}
+
+#[test]
+fn test_vec_i32_three_elements() {
+    Python::attach(|py| {
+        assert_eq!(round_trip(py, vec![1i32, -7, 100]), vec![1i32, -7, 100]);
+    });
+}
+
+// --- Vec<f64> ---
+
+#[test]
+fn test_vec_f64_three_elements() {
+    Python::attach(|py| {
+        let input = vec![0.0f64, -1.5, 3.14];
+        let result = round_trip(py, input.clone());
+        assert_eq!(result, input);
+    });
+}
+
+// --- Vec<String> ---
+
+#[test]
+fn test_vec_string_empty_vec() {
+    Python::attach(|py| {
+        let result = round_trip(py, Vec::<String>::new());
+        assert_eq!(result, Vec::<String>::new());
+    });
+}
+
+#[test]
+fn test_vec_string_empty_strings() {
+    Python::attach(|py| {
+        let input = vec!["".to_string(), "".to_string()];
+        assert_eq!(round_trip(py, input.clone()), input);
+    });
+}
+
+#[test]
+fn test_vec_string_non_empty() {
+    Python::attach(|py| {
+        let input = vec!["hello".to_string(), "world".to_string()];
+        assert_eq!(round_trip(py, input.clone()), input);
+    });
+}
+
+// --- Vec<bool> ---
+
+#[test]
+fn test_vec_bool_mixed() {
+    Python::attach(|py| {
+        let input = vec![true, false, true, false];
+        assert_eq!(round_trip(py, input.clone()), input);
+    });
+}
+
+// --- Vec<Vec<i32>> ---
+
+#[test]
+fn test_vec_nested_two_inner_vecs() {
+    Python::attach(|py| {
+        let input = vec![vec![1i32, 2, 3], vec![-1i32, 0]];
+        assert_eq!(round_trip(py, input.clone()), input);
+    });
+}
+
+// --- Tuple characterisation ---
+
+#[test]
+fn test_tuple_i32_string_round_trip_ok() {
+    Python::attach(|py| {
+        let input = (7i32, "hello".to_string());
+        let py_val = pythonize(py, &input).expect("pythonize failed");
+        let result: (i32, String) = depythonize(&py_val).expect("depythonize failed");
+        assert_eq!(result.0, 7i32);
+        assert_eq!(result.1, "hello");
+    });
+}
+
+#[test]
+fn test_tuple_bool_f64_i64_round_trip_ok() {
+    Python::attach(|py| {
+        let input = (true, 2.718f64, -42i64);
+        let py_val = pythonize(py, &input).expect("pythonize failed");
+        let result: (bool, f64, i64) = depythonize(&py_val).expect("depythonize failed");
+        assert_eq!(result.0, true);
+        assert_eq!(result.1, 2.718f64);
+        assert_eq!(result.2, -42i64);
+    });
+}
+
+// --- HashMap<String, i64> ---
+
+#[test]
+fn test_hashmap_string_i64_empty() {
+    Python::attach(|py| {
+        let input: HashMap<String, i64> = hashmap! {};
+        let result = round_trip(py, input);
+        assert_eq!(result, HashMap::new());
+    });
+}
+
+#[test]
+fn test_hashmap_string_i64_three_entries() {
+    Python::attach(|py| {
+        let input: HashMap<String, i64> = hashmap! {
+            "a".to_string() => 1,
+            "b".to_string() => -2,
+            "c".to_string() => 300,
+        };
+        let result = round_trip(py, input.clone());
+        assert_eq!(result, input);
+    });
+}
+
+#[test]
+fn test_hashmap_string_vec_i32_two_entries() {
+    Python::attach(|py| {
+        let input: HashMap<String, Vec<i32>> = hashmap! {
+            "evens".to_string() => vec![2, 4, 6],
+            "odds".to_string()  => vec![1, 3, 5],
+        };
+        let result = round_trip(py, input.clone());
+        assert_eq!(result, input);
+    });
+}
+
+#[test]
+fn test_hashmap_string_bool_two_entries() {
+    Python::attach(|py| {
+        let input: HashMap<String, bool> = hashmap! {
+            "yes".to_string() => true,
+            "no".to_string()  => false,
+        };
+        let result = round_trip(py, input.clone());
+        assert_eq!(result, input);
+    });
+}
+
+// --- BTreeMap<String, i64> ---
+
+#[test]
+fn test_btreemap_string_i64_empty() {
+    Python::attach(|py| {
+        let input: BTreeMap<String, i64> = btreemap! {};
+        let result = round_trip(py, input);
+        assert_eq!(result, BTreeMap::new());
+    });
+}
+
+#[test]
+fn test_btreemap_string_i64_three_entries() {
+    Python::attach(|py| {
+        let input: BTreeMap<String, i64> = btreemap! {
+            "alpha".to_string()   => 10,
+            "beta".to_string()    => -20,
+            "gamma".to_string()   => 300,
+        };
+        let result = round_trip(py, input.clone());
+        assert_eq!(result, input);
+    });
+}
+
+#[test]
+fn test_btreemap_string_string_two_entries() {
+    Python::attach(|py| {
+        let input: BTreeMap<String, String> = btreemap! {
+            "key1".to_string() => "value1".to_string(),
+            "key2".to_string() => "value2".to_string(),
+        };
+        let result = round_trip(py, input.clone());
+        assert_eq!(result, input);
+    });
+}
diff --git a/tests/test_custom_types.rs b/tests/test_custom_types.rs
index 5f0084b..27888d0 100644
--- a/tests/test_custom_types.rs
+++ b/tests/test_custom_types.rs
@@ -4,6 +4,7 @@ use pyo3::{
     exceptions::{PyIndexError, PyKeyError},
     prelude::*,
     types::{PyDict, PyMapping, PySequence, PyTuple},
+    IntoPyObjectExt,
 };
 use pythonize::{
     depythonize, pythonize_custom, PythonizeListType, PythonizeMappingType,
@@ -14,7 +15,7 @@ use serde_json::{json, Value};
 
 #[pyclass(sequence)]
 struct CustomList {
-    items: Vec<PyObject>,
+    items: Vec<Py<PyAny>>,
 }
 
 #[pymethods]
@@ -23,7 +24,7 @@ impl CustomList {
         self.items.len()
     }
 
-    fn __getitem__(&self, idx: isize) -> PyResult<PyObject> {
+    fn __getitem__(&self, idx: isize) -> PyResult<Py<PyAny>> {
         self.items
             .get(idx as usize)
             .cloned()
@@ -32,12 +33,12 @@ impl CustomList {
 }
 
 impl PythonizeListType for CustomList {
-    fn create_sequence<T, U>(
-        py: Python,
+    fn create_sequence<'py, T, U>(
+        py: Python<'py>,
         elements: impl IntoIterator<Item = T, IntoIter = U>,
-    ) -> PyResult<Bound<PySequence>>
+    ) -> PyResult<Bound<'py, PySequence>>
     where
-        T: ToPyObject,
+        T: IntoPyObject<'py>,
         U: ExactSizeIterator<Item = T>,
     {
         let sequence = Bound::new(
@@ -45,26 +46,25 @@ impl PythonizeListType for CustomList {
             CustomList {
                 items: elements
                     .into_iter()
-                    .map(|item| item.to_object(py))
-                    .collect(),
+                    .map(|item| item.into_py_any(py))
+                    .collect::<PyResult<_>>()?,
             },
-        )?
-        .into_any();
+        )?;
 
-        Ok(unsafe { sequence.downcast_into_unchecked() })
+        Ok(unsafe { sequence.cast_into_unchecked() })
     }
 }
 
 struct PythonizeCustomList;
-impl<'py> PythonizeTypes<'py> for PythonizeCustomList {
+impl<'py> PythonizeTypes for PythonizeCustomList {
     type Map = PyDict;
-    type NamedMap = PythonizeUnnamedMappingAdapter<'py, PyDict>;
+    type NamedMap = PythonizeUnnamedMappingAdapter<PyDict>;
     type List = CustomList;
 }
 
 #[test]
 fn test_custom_list() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PySequence::register::<CustomList>(py).unwrap();
         let serialized = pythonize_custom::<PythonizeCustomList, _>(py, &json!([1, 2, 3])).unwrap();
         assert!(serialized.is_instance_of::<CustomList>());
@@ -76,7 +76,7 @@ fn test_custom_list() {
 
 #[pyclass(mapping)]
 struct CustomDict {
-    items: HashMap<String, PyObject>,
+    items: HashMap<String, Py<PyAny>>,
 }
 
 #[pymethods]
@@ -85,14 +85,14 @@ impl CustomDict {
         self.items.len()
     }
 
-    fn __getitem__(&self, key: String) -> PyResult<PyObject> {
+    fn __getitem__(&self, key: String) -> PyResult<Py<PyAny>> {
         self.items
             .get(&key)
             .cloned()
             .ok_or_else(|| PyKeyError::new_err(key))
     }
 
-    fn __setitem__(&mut self, key: String, value: PyObject) {
+    fn __setitem__(&mut self, key: String, value: Py<PyAny>) {
         self.items.insert(key, value);
     }
 
@@ -100,15 +100,15 @@ impl CustomDict {
         self.items.keys().collect()
     }
 
-    fn values(&self) -> Vec<PyObject> {
+    fn values(&self) -> Vec<Py<PyAny>> {
         self.items.values().cloned().collect()
     }
 }
 
-impl<'py> PythonizeMappingType<'py> for CustomDict {
-    type Builder = Bound<'py, CustomDict>;
+impl PythonizeMappingType for CustomDict {
+    type Builder<'py> = Bound<'py, CustomDict>;
 
-    fn builder(py: Python<'py>, len: Option<usize>) -> PyResult<Self::Builder> {
+    fn builder<'py>(py: Python<'py>, len: Option<usize>) -> PyResult<Self::Builder<'py>> {
         Bound::new(
             py,
             CustomDict {
@@ -117,29 +117,29 @@ impl<'py> PythonizeMappingType<'py> for CustomDict {
         )
     }
 
-    fn push_item(
-        builder: &mut Self::Builder,
+    fn push_item<'py>(
+        builder: &mut Self::Builder<'py>,
         key: Bound<'py, PyAny>,
         value: Bound<'py, PyAny>,
     ) -> PyResult<()> {
-        unsafe { builder.downcast_unchecked::<PyMapping>() }.set_item(key, value)
+        unsafe { builder.cast_unchecked::<PyMapping>() }.set_item(key, value)
     }
 
-    fn finish(builder: Self::Builder) -> PyResult<Bound<'py, PyMapping>> {
-        Ok(unsafe { builder.into_any().downcast_into_unchecked() })
+    fn finish<'py>(builder: Self::Builder<'py>) -> PyResult<Bound<'py, PyMapping>> {
+        Ok(unsafe { builder.cast_into_unchecked() })
     }
 }
 
 struct PythonizeCustomDict;
-impl<'py> PythonizeTypes<'py> for PythonizeCustomDict {
+impl<'py> PythonizeTypes for PythonizeCustomDict {
     type Map = CustomDict;
-    type NamedMap = PythonizeUnnamedMappingAdapter<'py, CustomDict>;
+    type NamedMap = PythonizeUnnamedMappingAdapter<CustomDict>;
     type List = PyTuple;
 }
 
 #[test]
 fn test_custom_dict() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PyMapping::register::<CustomDict>(py).unwrap();
         let serialized =
             pythonize_custom::<PythonizeCustomDict, _>(py, &json!({ "hello": 1, "world": 2 }))
@@ -153,7 +153,7 @@ fn test_custom_dict() {
 
 #[test]
 fn test_tuple() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PyMapping::register::<CustomDict>(py).unwrap();
         let serialized =
             pythonize_custom::<PythonizeCustomDict, _>(py, &json!([1, 2, 3, 4])).unwrap();
@@ -167,7 +167,7 @@ fn test_tuple() {
 #[test]
 fn test_pythonizer_can_be_created() {
     // https://github.com/davidhewitt/pythonize/pull/56
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let sample = json!({ "hello": 1, "world": 2 });
         assert!(sample
             .serialize(Pythonizer::new(py))
@@ -184,7 +184,7 @@ fn test_pythonizer_can_be_created() {
 #[pyclass(mapping)]
 struct NamedCustomDict {
     name: String,
-    items: HashMap<String, PyObject>,
+    items: HashMap<String, Py<PyAny>>,
 }
 
 #[pymethods]
@@ -193,14 +193,14 @@ impl NamedCustomDict {
         self.items.len()
     }
 
-    fn __getitem__(&self, key: String) -> PyResult<PyObject> {
+    fn __getitem__(&self, key: String) -> PyResult<Py<PyAny>> {
         self.items
             .get(&key)
             .cloned()
             .ok_or_else(|| PyKeyError::new_err(key))
     }
 
-    fn __setitem__(&mut self, key: String, value: PyObject) {
+    fn __setitem__(&mut self, key: String, value: Py<PyAny>) {
         self.items.insert(key, value);
     }
 
@@ -208,15 +208,19 @@ impl NamedCustomDict {
         self.items.keys().collect()
     }
 
-    fn values(&self) -> Vec<PyObject> {
+    fn values(&self) -> Vec<Py<PyAny>> {
         self.items.values().cloned().collect()
     }
 }
 
-impl<'py> PythonizeNamedMappingType<'py> for NamedCustomDict {
-    type Builder = Bound<'py, NamedCustomDict>;
+impl PythonizeNamedMappingType for NamedCustomDict {
+    type Builder<'py> = Bound<'py, NamedCustomDict>;
 
-    fn builder(py: Python<'py>, len: usize, name: &'static str) -> PyResult<Self::Builder> {
+    fn builder<'py>(
+        py: Python<'py>,
+        len: usize,
+        name: &'static str,
+    ) -> PyResult<Self::Builder<'py>> {
         Bound::new(
             py,
             NamedCustomDict {
@@ -226,21 +230,21 @@ impl<'py> PythonizeNamedMappingType<'py> for NamedCustomDict {
         )
     }
 
-    fn push_field(
-        builder: &mut Self::Builder,
+    fn push_field<'py>(
+        builder: &mut Self::Builder<'py>,
         name: Bound<'py, pyo3::types::PyString>,
         value: Bound<'py, PyAny>,
     ) -> PyResult<()> {
-        unsafe { builder.downcast_unchecked::<PyMapping>() }.set_item(name, value)
+        unsafe { builder.cast_unchecked::<PyMapping>() }.set_item(name, value)
     }
 
-    fn finish(builder: Self::Builder) -> PyResult<Bound<'py, PyMapping>> {
-        Ok(unsafe { builder.into_any().downcast_into_unchecked() })
+    fn finish<'py>(builder: Self::Builder<'py>) -> PyResult<Bound<'py, PyMapping>> {
+        Ok(unsafe { builder.cast_into_unchecked() })
     }
 }
 
 struct PythonizeNamedCustomDict;
-impl<'py> PythonizeTypes<'py> for PythonizeNamedCustomDict {
+impl<'py> PythonizeTypes for PythonizeNamedCustomDict {
     type Map = CustomDict;
     type NamedMap = NamedCustomDict;
     type List = PyTuple;
@@ -254,7 +258,7 @@ struct Struct {
 
 #[test]
 fn test_custom_unnamed_dict() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PyMapping::register::<CustomDict>(py).unwrap();
         let serialized =
             pythonize_custom::<PythonizeCustomDict, _>(py, &Struct { hello: 1, world: 2 }).unwrap();
@@ -267,7 +271,7 @@ fn test_custom_unnamed_dict() {
 
 #[test]
 fn test_custom_named_dict() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         PyMapping::register::<NamedCustomDict>(py).unwrap();
         let serialized =
             pythonize_custom::<PythonizeNamedCustomDict, _>(py, &Struct { hello: 1, world: 2 })
diff --git a/tests/test_structs.rs b/tests/test_structs.rs
new file mode 100644
index 0000000..b00899b
--- /dev/null
+++ b/tests/test_structs.rs
@@ -0,0 +1,222 @@
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use pythonize::{depythonize, pythonize};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct Simple {
+    name: String,
+    value: i64,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct WithRename {
+    #[serde(rename = "firstName")]
+    first_name: String,
+    age: i32,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct WithRenameAll {
+    first_name: String,
+    last_name: String,
+    year_of_birth: i32,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct WithOption {
+    label: String,
+    count: Option<i64>,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct Strict {
+    id: i32,
+    tag: String,
+}
+
+// --- Simple struct ---
+
+#[test]
+fn test_simple_round_trip() {
+    Python::attach(|py| {
+        let original = Simple {
+            name: "Alice".into(),
+            value: 42,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: Simple = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+#[test]
+fn test_simple_empty_string_zero() {
+    Python::attach(|py| {
+        let original = Simple {
+            name: String::new(),
+            value: 0,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: Simple = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+#[test]
+fn test_simple_boundary_i64_min() {
+    Python::attach(|py| {
+        let original = Simple {
+            name: "hello world".into(),
+            value: i64::MIN,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: Simple = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+// --- #[serde(rename)] ---
+
+#[test]
+fn test_rename_key_present() {
+    Python::attach(|py| {
+        let original = WithRename {
+            first_name: "Bob".into(),
+            age: 30,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let dict = py_obj.cast::<PyDict>().unwrap();
+        assert!(dict.get_item("firstName").unwrap().is_some());
+        assert!(dict.get_item("first_name").unwrap().is_none());
+    });
+}
+
+#[test]
+fn test_rename_round_trip() {
+    Python::attach(|py| {
+        let original = WithRename {
+            first_name: "Bob".into(),
+            age: 30,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: WithRename = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+// --- #[serde(rename_all = "camelCase")] ---
+
+#[test]
+fn test_rename_all_keys_present() {
+    Python::attach(|py| {
+        let original = WithRenameAll {
+            first_name: "Jane".into(),
+            last_name: "Doe".into(),
+            year_of_birth: 1990,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let dict = py_obj.cast::<PyDict>().unwrap();
+        assert!(dict.get_item("firstName").unwrap().is_some());
+        assert!(dict.get_item("lastName").unwrap().is_some());
+        assert!(dict.get_item("yearOfBirth").unwrap().is_some());
+    });
+}
+
+#[test]
+fn test_rename_all_round_trip() {
+    Python::attach(|py| {
+        let original = WithRenameAll {
+            first_name: "Jane".into(),
+            last_name: "Doe".into(),
+            year_of_birth: 1990,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: WithRenameAll = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+// --- Unknown fields (default: ignore) ---
+
+#[test]
+fn test_unknown_fields_ignored() {
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
+        dict.set_item("name", "test").unwrap();
+        dict.set_item("value", 1i64).unwrap();
+        dict.set_item("extra", "ignored").unwrap();
+        let result: Result<Simple, _> = depythonize(dict.as_any());
+        assert!(result.is_ok());
+        assert_eq!(
+            result.unwrap(),
+            Simple {
+                name: "test".into(),
+                value: 1
+            }
+        );
+    });
+}
+
+// --- #[serde(deny_unknown_fields)] ---
+
+#[test]
+fn test_deny_unknown_fields_fails() {
+    Python::attach(|py| {
+        let dict = PyDict::new(py);
+        dict.set_item("id", 1i32).unwrap();
+        dict.set_item("tag", "hello").unwrap();
+        dict.set_item("extra", "bad").unwrap();
+        let result: Result<Strict, _> = depythonize(dict.as_any());
+        assert!(result.is_err());
+    });
+}
+
+// --- Option<T> None ---
+
+#[test]
+fn test_option_none_round_trip() {
+    Python::attach(|py| {
+        let original = WithOption {
+            label: "x".into(),
+            count: None,
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let dict = py_obj.cast::<PyDict>().unwrap();
+        let count_opt = dict.get_item("count").unwrap();
+        assert!(count_opt.is_some());
+        assert!(count_opt.unwrap().is_none());
+        let result: WithOption = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+// --- Option<T> Some ---
+
+#[test]
+fn test_option_some_round_trip() {
+    Python::attach(|py| {
+        let original = WithOption {
+            label: "y".into(),
+            count: Some(99),
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: WithOption = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
+
+#[test]
+fn test_option_some_i64_max() {
+    Python::attach(|py| {
+        let original = WithOption {
+            label: "z".into(),
+            count: Some(i64::MAX),
+        };
+        let py_obj = pythonize(py, &original).unwrap();
+        let result: WithOption = depythonize(&py_obj).unwrap();
+        assert_eq!(result, original);
+    });
+}
diff --git a/tests/test_with_serde_path_to_err.rs b/tests/test_with_serde_path_to_err.rs
index 1321c2b..504dae9 100644
--- a/tests/test_with_serde_path_to_err.rs
+++ b/tests/test_with_serde_path_to_err.rs
@@ -13,9 +13,9 @@ struct Root<T> {
     root_map: BTreeMap<String, Nested<T>>,
 }
 
-impl<'py, T> PythonizeTypes<'py> for Root<T> {
+impl<'py, T> PythonizeTypes for Root<T> {
     type Map = PyDict;
-    type NamedMap = PythonizeUnnamedMappingAdapter<'py, PyDict>;
+    type NamedMap = PythonizeUnnamedMappingAdapter<PyDict>;
     type List = PyList;
 }
 
@@ -40,15 +40,15 @@ impl Serialize for CannotSerialize {
 
 #[test]
 fn test_de_valid() {
-    Python::with_gil(|py| {
-        let pyroot = PyDict::new_bound(py);
+    Python::attach(|py| {
+        let pyroot = PyDict::new(py);
         pyroot.set_item("root_key", "root_value").unwrap();
 
-        let nested = PyDict::new_bound(py);
-        let nested_0 = PyDict::new_bound(py);
+        let nested = PyDict::new(py);
+        let nested_0 = PyDict::new(py);
         nested_0.set_item("nested_key", "nested_value_0").unwrap();
         nested.set_item("nested_0", nested_0).unwrap();
-        let nested_1 = PyDict::new_bound(py);
+        let nested_1 = PyDict::new(py);
         nested_1.set_item("nested_key", "nested_value_1").unwrap();
         nested.set_item("nested_1", nested_1).unwrap();
 
@@ -82,15 +82,15 @@ fn test_de_valid() {
 
 #[test]
 fn test_de_invalid() {
-    Python::with_gil(|py| {
-        let pyroot = PyDict::new_bound(py);
+    Python::attach(|py| {
+        let pyroot = PyDict::new(py);
         pyroot.set_item("root_key", "root_value").unwrap();
 
-        let nested = PyDict::new_bound(py);
-        let nested_0 = PyDict::new_bound(py);
+        let nested = PyDict::new(py);
+        let nested_0 = PyDict::new(py);
         nested_0.set_item("nested_key", "nested_value_0").unwrap();
         nested.set_item("nested_0", nested_0).unwrap();
-        let nested_1 = PyDict::new_bound(py);
+        let nested_1 = PyDict::new(py);
         nested_1.set_item("nested_key", 1).unwrap();
         nested.set_item("nested_1", nested_1).unwrap();
 
@@ -100,13 +100,16 @@ fn test_de_invalid() {
         let err = serde_path_to_error::deserialize::<_, Root<String>>(de).unwrap_err();
 
         assert_eq!(err.path().to_string(), "root_map.nested_1.nested_key");
-        assert_eq!(err.to_string(), "root_map.nested_1.nested_key: unexpected type: 'int' object cannot be converted to 'PyString'");
+        assert_eq!(
+            err.to_string(),
+            "root_map.nested_1.nested_key: unexpected type: 'int' object is not an instance of 'str'"
+        );
     })
 }
 
 #[test]
 fn test_ser_valid() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let root = Root {
             root_key: String::from("root_value"),
             root_map: BTreeMap::from([
@@ -128,7 +131,7 @@ fn test_ser_valid() {
         let ser = pythonize::Pythonizer::<Root<String>>::from(py);
         let pyroot: Bound<'_, PyAny> = serde_path_to_error::serialize(&root, ser).unwrap();
 
-        let pyroot = pyroot.downcast::<PyDict>().unwrap();
+        let pyroot = pyroot.cast::<PyDict>().unwrap();
         assert_eq!(pyroot.len(), 2);
 
         let root_value: String = pyroot
@@ -143,7 +146,7 @@ fn test_ser_valid() {
             .get_item("root_map")
             .unwrap()
             .unwrap()
-            .downcast_into::<PyDict>()
+            .cast_into::<PyDict>()
             .unwrap();
         assert_eq!(root_map.len(), 2);
 
@@ -151,7 +154,7 @@ fn test_ser_valid() {
             .get_item("nested_0")
             .unwrap()
             .unwrap()
-            .downcast_into::<PyDict>()
+            .cast_into::<PyDict>()
             .unwrap();
         assert_eq!(nested_0.len(), 1);
         let nested_key_0: String = nested_0
@@ -166,7 +169,7 @@ fn test_ser_valid() {
             .get_item("nested_1")
             .unwrap()
             .unwrap()
-            .downcast_into::<PyDict>()
+            .cast_into::<PyDict>()
             .unwrap();
         assert_eq!(nested_1.len(), 1);
         let nested_key_1: String = nested_1
@@ -181,7 +184,7 @@ fn test_ser_valid() {
 
 #[test]
 fn test_ser_invalid() {
-    Python::with_gil(|py| {
+    Python::attach(|py| {
         let root = Root {
             root_key: String::from("root_value"),
             root_map: BTreeMap::from([