diff --git a/src/conversions/time.rs b/src/conversions/time.rs
index 8d723982efd..33dca2d318b 100644
--- a/src/conversions/time.rs
+++ b/src/conversions/time.rs
@@ -48,12 +48,12 @@ use crate::sync::GILOnceCell;
 use crate::types::any::PyAnyMethods;
 #[cfg(not(Py_LIMITED_API))]
 use crate::types::datetime::timezone_from_offset;
-use crate::types::PyNone;
 #[cfg(not(Py_LIMITED_API))]
 use crate::types::{
     PyDate, PyDateAccess, PyDateTime, PyDelta, PyDeltaAccess, PyTime, PyTimeAccess, PyTzInfo,
     PyTzInfoAccess,
 };
+use crate::types::{PyInt, PyNone};
 use crate::{ffi, Bound, FromPyObject, PyAny, PyErr, PyObject, PyResult, Python};
 #[cfg(Py_LIMITED_API)]
 use crate::{intern, DowncastError};
@@ -154,6 +154,24 @@ impl FromPyObject<'_> for Month {
     }
 }
 
+impl<'py> IntoPyObject<'py> for Month {
+    #[cfg(Py_LIMITED_API)]
+    type Target = PyInt;
+    #[cfg(not(Py_LIMITED_API))]
+    type Target = PyInt;
+    type Output = Bound<'py, Self::Target>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        (self as u8)
+            .into_pyobject(py)
+            .or_else(|_| Err(PyValueError::new_err("invalid month")))
+
+        // .map(|month| PyInt::::new(py, month.into()))
+        // .ok_or_else(|| PyValueError::new_err("invalid month"))
+    }
+}
+
 impl FromPyObject<'_> for Duration {
     fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Duration> {
         // Python size are much lower than rust size so we do not need bound checks.
@@ -852,733 +870,732 @@ fn timezone_utc(py: Python<'_>) -> Bound<'_, PyAny> {
     DatetimeTypes::get(py).timezone_utc.bind(py).clone()
 }
 
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-//     use crate::{types::PyTuple, BoundObject};
-//     use std::{cmp::Ordering, panic};
-
-//     #[test]
-//     // Only Python>=3.9 has the zoneinfo package
-//     // We skip the test on windows too since we'd need to install
-//     // tzdata there to make this work.
-//     #[cfg(all(Py_3_9, not(target_os = "windows")))]
-//     fn test_zoneinfo_is_not_fixed_offset() {
-//         use crate::ffi;
-//         use crate::types::any::PyAnyMethods;
-//         use crate::types::dict::PyDictMethods;
-
-//         Python::with_gil(|py| {
-//             let locals = crate::types::PyDict::new(py);
-//             py.run(
-//                 ffi::c_str!("import zoneinfo; zi = zoneinfo.ZoneInfo('Europe/London')"),
-//                 None,
-//                 Some(&locals),
-//             )
-//             .unwrap();
-//             let result: PyResult<FixedOffset> = locals.get_item("zi").unwrap().unwrap().extract();
-//             assert!(result.is_err());
-//             let res = result.err().unwrap();
-//             // Also check the error message is what we expect
-//             let msg = res.value(py).repr().unwrap().to_string();
-//             assert_eq!(msg, "TypeError(\"zoneinfo.ZoneInfo(key='Europe/London') is not a fixed offset timezone\")");
-//         });
-//     }
-
-//     #[test]
-//     fn test_timezone_aware_to_naive_fails() {
-//         // Test that if a user tries to convert a python's timezone aware datetime into a naive
-//         // one, the conversion fails.
-//         Python::with_gil(|py| {
-//             let py_datetime =
-//                 new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0, python_utc(py)));
-//             // Now test that converting a PyDateTime with tzinfo to a PrimitiveDateTime fails
-//             let res: PyResult<PrimitiveDateTime> = py_datetime.extract();
-//             assert_eq!(
-//                 res.unwrap_err().value(py).repr().unwrap().to_string(),
-//                 "TypeError('expected a datetime without tzinfo')"
-//             );
-//         });
-//     }
-
-//     #[test]
-//     fn test_naive_to_timezone_aware_fails() {
-//         // Test that if a user tries to convert a python's timezone aware datetime into a naive
-//         // one, the conversion fails.
-//         Python::with_gil(|py| {
-//             let py_datetime = new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0));
-//             // Now test that converting a PyDateTime with tzinfo to a PrimitiveDateTime fails
-//             let res: PyResult<OffsetDateTime<Utc>> = py_datetime.extract();
-//             assert_eq!(
-//                 res.unwrap_err().value(py).repr().unwrap().to_string(),
-//                 "TypeError('expected a datetime with non-None tzinfo')"
-//             );
-
-//             // Now test that converting a PyDateTime with tzinfo to a PrimitiveDateTime fails
-//             let res: PyResult<OffsetDateTime<FixedOffset>> = py_datetime.extract();
-//             assert_eq!(
-//                 res.unwrap_err().value(py).repr().unwrap().to_string(),
-//                 "TypeError('expected a datetime with non-None tzinfo')"
-//             );
-//         });
-//     }
+#[cfg(test)]
+mod tests_time {
+    use super::*;
+    use crate::{types::PyTuple, BoundObject};
+    use std::{cmp::Ordering, panic};
+
+    #[test]
+    // Only Python>=3.9 has the zoneinfo package
+    // We skip the test on windows too since we'd need to install
+    // tzdata there to make this work.
+    #[cfg(all(Py_3_9, not(target_os = "windows")))]
+    fn test_zoneinfo_is_not_fixed_offset() {
+        use crate::ffi;
+        use crate::types::any::PyAnyMethods;
+        use crate::types::dict::PyDictMethods;
+
+        Python::with_gil(|py| {
+            let locals = crate::types::PyDict::new(py);
+            py.run(
+                ffi::c_str!("import zoneinfo; zi = zoneinfo.ZoneInfo('Europe/London')"),
+                None,
+                Some(&locals),
+            )
+            .unwrap();
+            let result: PyResult<UtcOffset> = locals.get_item("zi").unwrap().unwrap().extract();
+            assert!(result.is_err());
+            let res = result.err().unwrap();
+            // Also check the error message is what we expect
+            let msg = res.value(py).repr().unwrap().to_string();
+            assert_eq!(msg, "TypeError(\"zoneinfo.ZoneInfo(key='Europe/London') is not a fixed offset timezone\")");
+        });
+    }
 
-//     #[test]
-//     fn test_invalid_types_fail() {
-//         // Test that if a user tries to convert a python's timezone aware datetime into a naive
-//         // one, the conversion fails.
-//         Python::with_gil(|py| {
-//             let none = py.None().into_bound(py);
-//             assert_eq!(
-//                 none.extract::<Duration>().unwrap_err().to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyDelta'"
-//             );
-//             assert_eq!(
-//                 none.extract::<FixedOffset>().unwrap_err().to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyTzInfo'"
-//             );
-//             assert_eq!(
-//                 none.extract::<Utc>().unwrap_err().to_string(),
-//                 "ValueError: expected datetime.timezone.utc"
-//             );
-//             assert_eq!(
-//                 none.extract::<Time>().unwrap_err().to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyTime'"
-//             );
-//             assert_eq!(
-//                 none.extract::<Date>().unwrap_err().to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyDate'"
-//             );
-//             assert_eq!(
-//                 none.extract::<PrimitiveDateTime>().unwrap_err().to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
-//             );
-//             assert_eq!(
-//                 none.extract::<OffsetDateTime<Utc>>()
-//                     .unwrap_err()
-//                     .to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
-//             );
-//             assert_eq!(
-//                 none.extract::<OffsetDateTime<FixedOffset>>()
-//                     .unwrap_err()
-//                     .to_string(),
-//                 "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
-//             );
-//         });
-//     }
+    #[test]
+    fn test_timezone_aware_to_naive_fails() {
+        // Test that if a user tries to convert a python's timezone aware datetime into a naive
+        // one, the conversion fails.
+        Python::with_gil(|py| {
+            let py_datetime =
+                new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0, python_utc(py)));
+            // Now test that converting a PyDateTime with tzinfo to a PrimitiveDateTime fails
+            let res: PyResult<PrimitiveDateTime> = py_datetime.extract();
+            assert_eq!(
+                res.unwrap_err().value(py).repr().unwrap().to_string(),
+                "TypeError('expected a datetime without tzinfo')"
+            );
+        });
+    }
 
-//     #[test]
-//     fn test_pyo3_timedelta_into_pyobject() {
-//         // Utility function used to check different durations.
-//         // The `name` parameter is used to identify the check in case of a failure.
-//         let check = |name: &'static str, delta: Duration, py_days, py_seconds, py_ms| {
-//             Python::with_gil(|py| {
-//                 let delta = delta.into_pyobject(py).unwrap();
-//                 let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
-//                 assert!(
-//                     delta.eq(&py_delta).unwrap(),
-//                     "{}: {} != {}",
-//                     name,
-//                     delta,
-//                     py_delta
-//                 );
-//             });
-//         };
-
-//         let delta = Duration::days(-1) + Duration::seconds(1) + Duration::microseconds(-10);
-//         check("delta normalization", delta, -1, 1, -10);
-
-//         // Check the minimum value allowed by PyDelta, which is different
-//         // from the minimum value allowed in Duration. This should pass.
-//         let delta = Duration::seconds(-86399999913600); // min
-//         check("delta min value", delta, -999999999, 0, 0);
-
-//         // Same, for max value
-//         let delta = Duration::seconds(86399999999999) + Duration::nanoseconds(999999000); // max
-//         check("delta max value", delta, 999999999, 86399, 999999);
-
-//         // Also check that trying to convert an out of bound value errors.
-//         Python::with_gil(|py| {
-//             assert!(Duration::min_value().into_pyobject(py).is_err());
-//             assert!(Duration::max_value().into_pyobject(py).is_err());
-//         });
-//     }
+    #[test]
+    fn test_naive_to_timezone_aware_fails() {
+        // Test that if a user tries to convert a python's timezone aware datetime into a naive
+        // one, the conversion fails.
+        Python::with_gil(|py| {
+            let py_datetime = new_py_datetime_ob(py, "datetime", (2022, 1, 1, 1, 0, 0, 0));
+            // Now test that converting a PyDateTime with tzinfo to a PrimitiveDateTime fails
+            let res: PyResult<OffsetDateTime> = py_datetime.extract();
+            assert_eq!(
+                res.unwrap_err().value(py).repr().unwrap().to_string(),
+                "TypeError('expected a datetime with non-None tzinfo')"
+            );
+
+            // Now test that converting a PyDateTime with tzinfo to a PrimitiveDateTime fails
+            let res: PyResult<OffsetDateTime> = py_datetime.extract();
+            assert_eq!(
+                res.unwrap_err().value(py).repr().unwrap().to_string(),
+                "TypeError('expected a datetime with non-None tzinfo')"
+            );
+        });
+    }
 
-//     #[test]
-//     fn test_pyo3_timedelta_frompyobject() {
-//         // Utility function used to check different Durations.
-//         // The `name` parameter is used to identify the check in case of a failure.
-//         let check = |name: &'static str, delta: Duration, py_days, py_seconds, py_ms| {
-//             Python::with_gil(|py| {
-//                 let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
-//                 let py_delta: Duration = py_delta.extract().unwrap();
-//                 assert_eq!(py_delta, delta, "{}: {} != {}", name, py_delta, delta);
-//             })
-//         };
-
-//         // Check the minimum value allowed by PyDelta, which is different
-//         // from the minimum value allowed in Duration. This should pass.
-//         check(
-//             "min py_delta value",
-//             Duration::seconds(-86399999913600),
-//             -999999999,
-//             0,
-//             0,
-//         );
-//         // Same, for max value
-//         check(
-//             "max py_delta value",
-//             Duration::seconds(86399999999999) + Duration::microseconds(999999),
-//             999999999,
-//             86399,
-//             999999,
-//         );
-
-//         // This check is to assert that we can't construct every possible Duration from a PyDelta
-//         // since they have different bounds.
-//         Python::with_gil(|py| {
-//             let low_days: i32 = -1000000000;
-//             // This is possible
-//             assert!(panic::catch_unwind(|| Duration::days(low_days as i64)).is_ok());
-//             // This panics on PyDelta::new
-//             assert!(panic::catch_unwind(|| {
-//                 let py_delta = new_py_datetime_ob(py, "timedelta", (low_days, 0, 0));
-//                 if let Ok(_duration) = py_delta.extract::<Duration>() {
-//                     // So we should never get here
-//                 }
-//             })
-//             .is_err());
-
-//             let high_days: i32 = 1000000000;
-//             // This is possible
-//             assert!(panic::catch_unwind(|| Duration::days(high_days as i64)).is_ok());
-//             // This panics on PyDelta::new
-//             assert!(panic::catch_unwind(|| {
-//                 let py_delta = new_py_datetime_ob(py, "timedelta", (high_days, 0, 0));
-//                 if let Ok(_duration) = py_delta.extract::<Duration>() {
-//                     // So we should never get here
-//                 }
-//             })
-//             .is_err());
-//         });
-//     }
+    #[test]
+    fn test_invalid_types_fail() {
+        // Test that if a user tries to convert a python's timezone aware datetime into a naive
+        // one, the conversion fails.
+        Python::with_gil(|py| {
+            let none = py.None().into_bound(py);
+            assert_eq!(
+                none.extract::<Duration>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyDelta'"
+            );
+            assert_eq!(
+                none.extract::<UtcOffset>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyTzInfo'"
+            );
+            // assert_eq!(
+            //     none.extract::<Utc>().unwrap_err().to_string(),
+            //     "ValueError: expected datetime.timezone.utc"
+            // );
+            assert_eq!(
+                none.extract::<Time>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyTime'"
+            );
+            assert_eq!(
+                none.extract::<Date>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyDate'"
+            );
+            assert_eq!(
+                none.extract::<PrimitiveDateTime>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
+            );
+            assert_eq!(
+                none.extract::<OffsetDateTime>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
+            );
+            assert_eq!(
+                none.extract::<OffsetDateTime>().unwrap_err().to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'PyDateTime'"
+            );
+        });
+    }
 
-//     #[test]
-//     fn test_pyo3_date_into_pyobject() {
-//         let eq_ymd = |name: &'static str, year, month, day| {
-//             Python::with_gil(|py| {
-//                 let date = Date::from_ymd_opt(year, month, day)
-//                     .unwrap()
-//                     .into_pyobject(py)
-//                     .unwrap();
-//                 let py_date = new_py_datetime_ob(py, "date", (year, month, day));
-//                 assert_eq!(
-//                     date.compare(&py_date).unwrap(),
-//                     Ordering::Equal,
-//                     "{}: {} != {}",
-//                     name,
-//                     date,
-//                     py_date
-//                 );
-//             })
-//         };
-
-//         eq_ymd("past date", 2012, 2, 29);
-//         eq_ymd("min date", 1, 1, 1);
-//         eq_ymd("future date", 3000, 6, 5);
-//         eq_ymd("max date", 9999, 12, 31);
-//     }
+    #[test]
+    fn test_pyo3_timedelta_into_pyobject() {
+        // Utility function used to check different durations.
+        // The `name` parameter is used to identify the check in case of a failure.
+        let check = |name: &'static str, delta: Duration, py_days, py_seconds, py_ms| {
+            Python::with_gil(|py| {
+                let delta = delta.into_pyobject(py).unwrap();
+                let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
+                assert!(
+                    delta.eq(&py_delta).unwrap(),
+                    "{}: {} != {}",
+                    name,
+                    delta,
+                    py_delta
+                );
+            });
+        };
 
-//     #[test]
-//     fn test_pyo3_date_frompyobject() {
-//         let eq_ymd = |name: &'static str, year, month, day| {
-//             Python::with_gil(|py| {
-//                 let py_date = new_py_datetime_ob(py, "date", (year, month, day));
-//                 let py_date: Date = py_date.extract().unwrap();
-//                 let date = Date::from_ymd_opt(year, month, day).unwrap();
-//                 assert_eq!(py_date, date, "{}: {} != {}", name, date, py_date);
-//             })
-//         };
-
-//         eq_ymd("past date", 2012, 2, 29);
-//         eq_ymd("min date", 1, 1, 1);
-//         eq_ymd("future date", 3000, 6, 5);
-//         eq_ymd("max date", 9999, 12, 31);
-//     }
+        let delta = Duration::days(-1) + Duration::seconds(1) + Duration::microseconds(-10);
+        check("delta normalization", delta, -1, 1, -10);
 
-//     #[test]
-//     fn test_pyo3_datetime_into_pyobject_utc() {
-//         Python::with_gil(|py| {
-//             let check_utc =
-//                 |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
-//                     let datetime = Date::from_ymd_opt(year, month, day)
-//                         .unwrap()
-//                         .and_hms_micro_opt(hour, minute, second, ms)
-//                         .unwrap()
-//                         .and_utc();
-//                     let datetime = datetime.into_pyobject(py).unwrap();
-//                     let py_datetime = new_py_datetime_ob(
-//                         py,
-//                         "datetime",
-//                         (
-//                             year,
-//                             month,
-//                             day,
-//                             hour,
-//                             minute,
-//                             second,
-//                             py_ms,
-//                             python_utc(py),
-//                         ),
-//                     );
-//                     assert_eq!(
-//                         datetime.compare(&py_datetime).unwrap(),
-//                         Ordering::Equal,
-//                         "{}: {} != {}",
-//                         name,
-//                         datetime,
-//                         py_datetime
-//                     );
-//                 };
-
-//             check_utc("regular", 2014, 5, 6, 7, 8, 9, 999_999, 999_999);
-
-//             #[cfg(not(Py_GIL_DISABLED))]
-//             assert_warnings!(
-//                 py,
-//                 check_utc("leap second", 2014, 5, 6, 7, 8, 59, 1_999_999, 999_999),
-//                 [(
-//                     PyUserWarning,
-//                     "ignored leap-second, `datetime` does not support leap-seconds"
-//                 )]
-//             );
-//         })
-//     }
+        // Check the minimum value allowed by PyDelta, which is different
+        // from the minimum value allowed in Duration. This should pass.
+        let delta = Duration::seconds(-86399999913600); // min
+        check("delta min value", delta, -999999999, 0, 0);
 
-//     #[test]
-//     fn test_pyo3_datetime_into_pyobject_fixed_offset() {
-//         Python::with_gil(|py| {
-//             let check_fixed_offset =
-//                 |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
-//                     let offset = FixedOffset::east_opt(3600).unwrap();
-//                     let datetime = Date::from_ymd_opt(year, month, day)
-//                         .unwrap()
-//                         .and_hms_micro_opt(hour, minute, second, ms)
-//                         .unwrap()
-//                         .and_local_timezone(offset)
-//                         .unwrap();
-//                     let datetime = datetime.into_pyobject(py).unwrap();
-//                     let py_tz = offset.into_pyobject(py).unwrap();
-//                     let py_datetime = new_py_datetime_ob(
-//                         py,
-//                         "datetime",
-//                         (year, month, day, hour, minute, second, py_ms, py_tz),
-//                     );
-//                     assert_eq!(
-//                         datetime.compare(&py_datetime).unwrap(),
-//                         Ordering::Equal,
-//                         "{}: {} != {}",
-//                         name,
-//                         datetime,
-//                         py_datetime
-//                     );
-//                 };
-
-//             check_fixed_offset("regular", 2014, 5, 6, 7, 8, 9, 999_999, 999_999);
-
-//             #[cfg(not(Py_GIL_DISABLED))]
-//             assert_warnings!(
-//                 py,
-//                 check_fixed_offset("leap second", 2014, 5, 6, 7, 8, 59, 1_999_999, 999_999),
-//                 [(
-//                     PyUserWarning,
-//                     "ignored leap-second, `datetime` does not support leap-seconds"
-//                 )]
-//             );
-//         })
-//     }
+        // Same, for max value
+        let delta = Duration::seconds(86399999999999) + Duration::nanoseconds(999999000); // max
+        check("delta max value", delta, 999999999, 86399, 999999);
 
-//     #[test]
-//     fn test_pyo3_datetime_frompyobject_utc() {
-//         Python::with_gil(|py| {
-//             let year = 2014;
-//             let month = 5;
-//             let day = 6;
-//             let hour = 7;
-//             let minute = 8;
-//             let second = 9;
-//             let micro = 999_999;
-//             let tz_utc = timezone_utc(py);
-//             let py_datetime = new_py_datetime_ob(
-//                 py,
-//                 "datetime",
-//                 (year, month, day, hour, minute, second, micro, tz_utc),
-//             );
-//             let py_datetime: OffsetDateTime<Utc> = py_datetime.extract().unwrap();
-//             let datetime = Date::from_ymd_opt(year, month, day)
-//                 .unwrap()
-//                 .and_hms_micro_opt(hour, minute, second, micro)
-//                 .unwrap()
-//                 .and_utc();
-//             assert_eq!(py_datetime, datetime,);
-//         })
-//     }
-
-//     #[test]
-//     fn test_pyo3_datetime_frompyobject_fixed_offset() {
-//         Python::with_gil(|py| {
-//             let year = 2014;
-//             let month = 5;
-//             let day = 6;
-//             let hour = 7;
-//             let minute = 8;
-//             let second = 9;
-//             let micro = 999_999;
-//             let offset = FixedOffset::east_opt(3600).unwrap();
-//             let py_tz = offset.into_pyobject(py).unwrap();
-//             let py_datetime = new_py_datetime_ob(
-//                 py,
-//                 "datetime",
-//                 (year, month, day, hour, minute, second, micro, py_tz),
-//             );
-//             let datetime_from_py: OffsetDateTime<FixedOffset> = py_datetime.extract().unwrap();
-//             let datetime = Date::from_ymd_opt(year, month, day)
-//                 .unwrap()
-//                 .and_hms_micro_opt(hour, minute, second, micro)
-//                 .unwrap();
-//             let datetime = datetime.and_local_timezone(offset).unwrap();
-
-//             assert_eq!(datetime_from_py, datetime);
-//             assert!(
-//                 py_datetime.extract::<OffsetDateTime<Utc>>().is_err(),
-//                 "Extracting Utc from nonzero FixedOffset timezone will fail"
-//             );
-
-//             let utc = python_utc(py);
-//             let py_datetime_utc = new_py_datetime_ob(
-//                 py,
-//                 "datetime",
-//                 (year, month, day, hour, minute, second, micro, utc),
-//             );
-//             assert!(
-//                 py_datetime_utc
-//                     .extract::<OffsetDateTime<FixedOffset>>()
-//                     .is_ok(),
-//                 "Extracting FixedOffset from Utc timezone will succeed"
-//             );
-//         })
-//     }
+        // Also check that trying to convert an out of bound value errors.
+        Python::with_gil(|py| {
+            assert!(Duration::MIN.into_pyobject(py).is_err());
+            assert!(Duration::MAX.into_pyobject(py).is_err());
+        });
+    }
 
-//     #[test]
-//     fn test_pyo3_offset_fixed_into_pyobject() {
-//         Python::with_gil(|py| {
-//             // Chrono offset
-//             let offset = FixedOffset::east_opt(3600)
-//                 .unwrap()
-//                 .into_pyobject(py)
-//                 .unwrap();
-//             // Python timezone from timedelta
-//             let td = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
-//             let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
-//             // Should be equal
-//             assert!(offset.eq(py_timedelta).unwrap());
-
-//             // Same but with negative values
-//             let offset = FixedOffset::east_opt(-3600)
-//                 .unwrap()
-//                 .into_pyobject(py)
-//                 .unwrap();
-//             let td = new_py_datetime_ob(py, "timedelta", (0, -3600, 0));
-//             let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
-//             assert!(offset.eq(py_timedelta).unwrap());
-//         })
-//     }
+    #[test]
+    fn test_pyo3_timedelta_frompyobject() {
+        // Utility function used to check different Durations.
+        // The `name` parameter is used to identify the check in case of a failure.
+        let check = |name: &'static str, delta: Duration, py_days, py_seconds, py_ms| {
+            Python::with_gil(|py| {
+                let py_delta = new_py_datetime_ob(py, "timedelta", (py_days, py_seconds, py_ms));
+                let py_delta: Duration = py_delta.extract().unwrap();
+                assert_eq!(py_delta, delta, "{}: {} != {}", name, py_delta, delta);
+            })
+        };
 
-//     #[test]
-//     fn test_pyo3_offset_fixed_frompyobject() {
-//         Python::with_gil(|py| {
-//             let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
-//             let py_tzinfo = new_py_datetime_ob(py, "timezone", (py_timedelta,));
-//             let offset: FixedOffset = py_tzinfo.extract().unwrap();
-//             assert_eq!(FixedOffset::east_opt(3600).unwrap(), offset);
-//         })
-//     }
+        // Check the minimum value allowed by PyDelta, which is different
+        // from the minimum value allowed in Duration. This should pass.
+        check(
+            "min py_delta value",
+            Duration::seconds(-86399999913600),
+            -999999999,
+            0,
+            0,
+        );
+        // Same, for max value
+        check(
+            "max py_delta value",
+            Duration::seconds(86399999999999) + Duration::microseconds(999999),
+            999999999,
+            86399,
+            999999,
+        );
+
+        // This check is to assert that we can't construct every possible Duration from a PyDelta
+        // since they have different bounds.
+        Python::with_gil(|py| {
+            let low_days: i32 = -1000000000;
+            // This is possible
+            assert!(panic::catch_unwind(|| Duration::days(low_days as i64)).is_ok());
+            // This panics on PyDelta::new
+            assert!(panic::catch_unwind(|| {
+                let py_delta = new_py_datetime_ob(py, "timedelta", (low_days, 0, 0));
+                if let Ok(_duration) = py_delta.extract::<Duration>() {
+                    // So we should never get here
+                }
+            })
+            .is_err());
+
+            let high_days: i32 = 1000000000;
+            // This is possible
+            assert!(panic::catch_unwind(|| Duration::days(high_days as i64)).is_ok());
+            // This panics on PyDelta::new
+            assert!(panic::catch_unwind(|| {
+                let py_delta = new_py_datetime_ob(py, "timedelta", (high_days, 0, 0));
+                if let Ok(_duration) = py_delta.extract::<Duration>() {
+                    // So we should never get here
+                }
+            })
+            .is_err());
+        });
+    }
 
-//     #[test]
-//     fn test_pyo3_offset_utc_into_pyobject() {
-//         Python::with_gil(|py| {
-//             let utc = Utc.into_pyobject(py).unwrap();
-//             let py_utc = python_utc(py);
-//             assert!(utc.is(&py_utc));
-//         })
-//     }
+    #[test]
+    fn test_pyo3_date_into_pyobject() {
+        let eq_ymd = |name: &'static str, year, month, day| {
+            Python::with_gil(|py| {
+                let month = Month::try_from(month).unwrap();
+                let date = Date::from_calendar_date(year, month, day)
+                    .unwrap()
+                    .into_pyobject(py)
+                    .unwrap();
+                let py_date = new_py_datetime_ob(py, "date", (year, month, day));
+                assert_eq!(
+                    date.compare(&py_date).unwrap(),
+                    Ordering::Equal,
+                    "{}: {} != {}",
+                    name,
+                    date,
+                    py_date
+                );
+            })
+        };
 
-//     #[test]
-//     fn test_pyo3_offset_utc_frompyobject() {
-//         Python::with_gil(|py| {
-//             let py_utc = python_utc(py);
-//             let py_utc: Utc = py_utc.extract().unwrap();
-//             assert_eq!(Utc, py_utc);
-
-//             let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 0, 0));
-//             let py_timezone_utc = new_py_datetime_ob(py, "timezone", (py_timedelta,));
-//             let py_timezone_utc: Utc = py_timezone_utc.extract().unwrap();
-//             assert_eq!(Utc, py_timezone_utc);
-
-//             let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
-//             let py_timezone = new_py_datetime_ob(py, "timezone", (py_timedelta,));
-//             assert!(py_timezone.extract::<Utc>().is_err());
-//         })
-//     }
+        eq_ymd("past date", 2012, 2, 29);
+        eq_ymd("min date", 1, 1, 1);
+        eq_ymd("future date", 3000, 6, 5);
+        eq_ymd("max date", 9999, 12, 31);
+    }
 
-//     #[test]
-//     fn test_pyo3_time_into_pyobject() {
-//         Python::with_gil(|py| {
-//             let check_time = |name: &'static str, hour, minute, second, ms, py_ms| {
-//                 let time = Time::from_hms_micro_opt(hour, minute, second, ms)
-//                     .unwrap()
-//                     .into_pyobject(py)
-//                     .unwrap();
-//                 let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, py_ms));
-//                 assert!(
-//                     time.eq(&py_time).unwrap(),
-//                     "{}: {} != {}",
-//                     name,
-//                     time,
-//                     py_time
-//                 );
-//             };
-
-//             check_time("regular", 3, 5, 7, 999_999, 999_999);
-
-//             #[cfg(not(Py_GIL_DISABLED))]
-//             assert_warnings!(
-//                 py,
-//                 check_time("leap second", 3, 5, 59, 1_999_999, 999_999),
-//                 [(
-//                     PyUserWarning,
-//                     "ignored leap-second, `datetime` does not support leap-seconds"
-//                 )]
-//             );
-//         })
-//     }
+    #[test]
+    fn test_pyo3_date_frompyobject() {
+        let eq_ymd = |name: &'static str, year, month, day| {
+            let month = Month::try_from(month).unwrap();
+            Python::with_gil(|py| {
+                let py_date = new_py_datetime_ob(py, "date", (year, month, day));
+                let py_date: Date = py_date.extract().unwrap();
+                let date = Date::from_calendar_date(year, month, day).unwrap();
+                assert_eq!(py_date, date, "{}: {} != {}", name, date, py_date);
+            })
+        };
 
-//     #[test]
-//     fn test_pyo3_time_frompyobject() {
-//         let hour = 3;
-//         let minute = 5;
-//         let second = 7;
-//         let micro = 999_999;
-//         Python::with_gil(|py| {
-//             let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, micro));
-//             let py_time: Time = py_time.extract().unwrap();
-//             let time = Time::from_hms_micro_opt(hour, minute, second, micro).unwrap();
-//             assert_eq!(py_time, time);
-//         })
-//     }
+        eq_ymd("past date", 2012, 2, 29);
+        eq_ymd("min date", 1, 1, 1);
+        eq_ymd("future date", 3000, 6, 5);
+        eq_ymd("max date", 9999, 12, 31);
+    }
 
-//     fn new_py_datetime_ob<'py, A>(py: Python<'py>, name: &str, args: A) -> Bound<'py, PyAny>
-//     where
-//         A: IntoPyObject<'py, Target = PyTuple>,
-//     {
-//         py.import("datetime")
-//             .unwrap()
-//             .getattr(name)
-//             .unwrap()
-//             .call1(
-//                 args.into_pyobject(py)
-//                     .map_err(Into::into)
-//                     .unwrap()
-//                     .into_bound(),
-//             )
-//             .unwrap()
-//     }
+    // #[test]
+    // fn test_pyo3_datetime_into_pyobject_utc() {
+    //     Python::with_gil(|py| {
+    //         let check_utc =
+    //             |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
+    //                 let month = Month::try_from(month).unwrap();
+    //                 let datetime = Date::from_calendar_date(year, month, day)
+    //                     .unwrap()
+    //                     .with_hms_micro(hour, minute, second, ms)
+    //                     .unwrap()
+    //                     .assume_utc();
+    //                 let datetime = datetime.into_pyobject(py).unwrap();
+    //                 let py_datetime = new_py_datetime_ob(
+    //                     py,
+    //                     "datetime",
+    //                     (
+    //                         year,
+    //                         month as u8,
+    //                         day,
+    //                         hour,
+    //                         minute,
+    //                         second,
+    //                         py_ms,
+    //                         python_utc(py),
+    //                     ),
+    //                 );
+    //                 assert_eq!(
+    //                     datetime.compare(&py_datetime).unwrap(),
+    //                     Ordering::Equal,
+    //                     "{}: {} != {}",
+    //                     name,
+    //                     datetime,
+    //                     py_datetime
+    //                 );
+    //             };
+
+    //         check_utc("regular", 2014, 5, 6, 7, 8, 9, 999_999, 999_999);
+
+    //         #[cfg(not(Py_GIL_DISABLED))]
+    //         assert_warnings!(
+    //             py,
+    //             check_utc("leap second", 2014, 5, 6, 7, 8, 59, 1_999_999, 999_999),
+    //             [(
+    //                 PyUserWarning,
+    //                 "ignored leap-second, `datetime` does not support leap-seconds"
+    //             )]
+    //         );
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_datetime_into_pyobject_fixed_offset() {
+    //     Python::with_gil(|py| {
+    //         let check_fixed_offset =
+    //             |name: &'static str, year, month, day, hour, minute, second, ms, py_ms| {
+    //                 let offset = FixedOffset::east_opt(3600).unwrap();
+    //                 let datetime = Date::from_ymd_opt(year, month, day)
+    //                     .unwrap()
+    //                     .and_hms_micro_opt(hour, minute, second, ms)
+    //                     .unwrap()
+    //                     .and_local_timezone(offset)
+    //                     .unwrap();
+    //                 let datetime = datetime.into_pyobject(py).unwrap();
+    //                 let py_tz = offset.into_pyobject(py).unwrap();
+    //                 let py_datetime = new_py_datetime_ob(
+    //                     py,
+    //                     "datetime",
+    //                     (year, month, day, hour, minute, second, py_ms, py_tz),
+    //                 );
+    //                 assert_eq!(
+    //                     datetime.compare(&py_datetime).unwrap(),
+    //                     Ordering::Equal,
+    //                     "{}: {} != {}",
+    //                     name,
+    //                     datetime,
+    //                     py_datetime
+    //                 );
+    //             };
+
+    //         check_fixed_offset("regular", 2014, 5, 6, 7, 8, 9, 999_999, 999_999);
+
+    //         #[cfg(not(Py_GIL_DISABLED))]
+    //         assert_warnings!(
+    //             py,
+    //             check_fixed_offset("leap second", 2014, 5, 6, 7, 8, 59, 1_999_999, 999_999),
+    //             [(
+    //                 PyUserWarning,
+    //                 "ignored leap-second, `datetime` does not support leap-seconds"
+    //             )]
+    //         );
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_datetime_frompyobject_utc() {
+    //     Python::with_gil(|py| {
+    //         let year = 2014;
+    //         let month = 5;
+    //         let day = 6;
+    //         let hour = 7;
+    //         let minute = 8;
+    //         let second = 9;
+    //         let micro = 999_999;
+    //         let tz_utc = timezone_utc(py);
+    //         let py_datetime = new_py_datetime_ob(
+    //             py,
+    //             "datetime",
+    //             (year, month, day, hour, minute, second, micro, tz_utc),
+    //         );
+    //         let py_datetime: OffsetDateTime<Utc> = py_datetime.extract().unwrap();
+    //         let datetime = Date::from_ymd_opt(year, month, day)
+    //             .unwrap()
+    //             .and_hms_micro_opt(hour, minute, second, micro)
+    //             .unwrap()
+    //             .and_utc();
+    //         assert_eq!(py_datetime, datetime,);
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_datetime_frompyobject_fixed_offset() {
+    //     Python::with_gil(|py| {
+    //         let year = 2014;
+    //         let month = 5;
+    //         let day = 6;
+    //         let hour = 7;
+    //         let minute = 8;
+    //         let second = 9;
+    //         let micro = 999_999;
+    //         let offset = FixedOffset::east_opt(3600).unwrap();
+    //         let py_tz = offset.into_pyobject(py).unwrap();
+    //         let py_datetime = new_py_datetime_ob(
+    //             py,
+    //             "datetime",
+    //             (year, month, day, hour, minute, second, micro, py_tz),
+    //         );
+    //         let datetime_from_py: OffsetDateTime<FixedOffset> = py_datetime.extract().unwrap();
+    //         let datetime = Date::from_ymd_opt(year, month, day)
+    //             .unwrap()
+    //             .and_hms_micro_opt(hour, minute, second, micro)
+    //             .unwrap();
+    //         let datetime = datetime.and_local_timezone(offset).unwrap();
+
+    //         assert_eq!(datetime_from_py, datetime);
+    //         assert!(
+    //             py_datetime.extract::<OffsetDateTime<Utc>>().is_err(),
+    //             "Extracting Utc from nonzero FixedOffset timezone will fail"
+    //         );
+
+    //         let utc = python_utc(py);
+    //         let py_datetime_utc = new_py_datetime_ob(
+    //             py,
+    //             "datetime",
+    //             (year, month, day, hour, minute, second, micro, utc),
+    //         );
+    //         assert!(
+    //             py_datetime_utc
+    //                 .extract::<OffsetDateTime<FixedOffset>>()
+    //                 .is_ok(),
+    //             "Extracting FixedOffset from Utc timezone will succeed"
+    //         );
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_offset_fixed_into_pyobject() {
+    //     Python::with_gil(|py| {
+    //         // Chrono offset
+    //         let offset = FixedOffset::east_opt(3600)
+    //             .unwrap()
+    //             .into_pyobject(py)
+    //             .unwrap();
+    //         // Python timezone from timedelta
+    //         let td = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
+    //         let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
+    //         // Should be equal
+    //         assert!(offset.eq(py_timedelta).unwrap());
+
+    //         // Same but with negative values
+    //         let offset = FixedOffset::east_opt(-3600)
+    //             .unwrap()
+    //             .into_pyobject(py)
+    //             .unwrap();
+    //         let td = new_py_datetime_ob(py, "timedelta", (0, -3600, 0));
+    //         let py_timedelta = new_py_datetime_ob(py, "timezone", (td,));
+    //         assert!(offset.eq(py_timedelta).unwrap());
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_offset_fixed_frompyobject() {
+    //     Python::with_gil(|py| {
+    //         let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
+    //         let py_tzinfo = new_py_datetime_ob(py, "timezone", (py_timedelta,));
+    //         let offset: FixedOffset = py_tzinfo.extract().unwrap();
+    //         assert_eq!(FixedOffset::east_opt(3600).unwrap(), offset);
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_offset_utc_into_pyobject() {
+    //     Python::with_gil(|py| {
+    //         let utc = Utc.into_pyobject(py).unwrap();
+    //         let py_utc = python_utc(py);
+    //         assert!(utc.is(&py_utc));
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_offset_utc_frompyobject() {
+    //     Python::with_gil(|py| {
+    //         let py_utc = python_utc(py);
+    //         let py_utc: Utc = py_utc.extract().unwrap();
+    //         assert_eq!(Utc, py_utc);
+
+    //         let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 0, 0));
+    //         let py_timezone_utc = new_py_datetime_ob(py, "timezone", (py_timedelta,));
+    //         let py_timezone_utc: Utc = py_timezone_utc.extract().unwrap();
+    //         assert_eq!(Utc, py_timezone_utc);
+
+    //         let py_timedelta = new_py_datetime_ob(py, "timedelta", (0, 3600, 0));
+    //         let py_timezone = new_py_datetime_ob(py, "timezone", (py_timedelta,));
+    //         assert!(py_timezone.extract::<Utc>().is_err());
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_time_into_pyobject() {
+    //     Python::with_gil(|py| {
+    //         let check_time = |name: &'static str, hour, minute, second, ms, py_ms| {
+    //             let time = Time::from_hms_micro_opt(hour, minute, second, ms)
+    //                 .unwrap()
+    //                 .into_pyobject(py)
+    //                 .unwrap();
+    //             let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, py_ms));
+    //             assert!(
+    //                 time.eq(&py_time).unwrap(),
+    //                 "{}: {} != {}",
+    //                 name,
+    //                 time,
+    //                 py_time
+    //             );
+    //         };
+
+    //         check_time("regular", 3, 5, 7, 999_999, 999_999);
+
+    //         #[cfg(not(Py_GIL_DISABLED))]
+    //         assert_warnings!(
+    //             py,
+    //             check_time("leap second", 3, 5, 59, 1_999_999, 999_999),
+    //             [(
+    //                 PyUserWarning,
+    //                 "ignored leap-second, `datetime` does not support leap-seconds"
+    //             )]
+    //         );
+    //     })
+    // }
+
+    // #[test]
+    // fn test_pyo3_time_frompyobject() {
+    //     let hour = 3;
+    //     let minute = 5;
+    //     let second = 7;
+    //     let micro = 999_999;
+    //     Python::with_gil(|py| {
+    //         let py_time = new_py_datetime_ob(py, "time", (hour, minute, second, micro));
+    //         let py_time: Time = py_time.extract().unwrap();
+    //         let time = Time::from_hms_micro_opt(hour, minute, second, micro).unwrap();
+    //         assert_eq!(py_time, time);
+    //     })
+    // }
+
+    fn new_py_datetime_ob<'py, A>(py: Python<'py>, name: &str, args: A) -> Bound<'py, PyAny>
+    where
+        A: IntoPyObject<'py, Target = PyTuple>,
+    {
+        py.import("datetime")
+            .unwrap()
+            .getattr(name)
+            .unwrap()
+            .call1(
+                args.into_pyobject(py)
+                    .map_err(Into::into)
+                    .unwrap()
+                    .into_bound(),
+            )
+            .unwrap()
+    }
 
-//     fn python_utc(py: Python<'_>) -> Bound<'_, PyAny> {
-//         py.import("datetime")
-//             .unwrap()
-//             .getattr("timezone")
-//             .unwrap()
-//             .getattr("utc")
-//             .unwrap()
-//     }
+    fn python_utc(py: Python<'_>) -> Bound<'_, PyAny> {
+        py.import("datetime")
+            .unwrap()
+            .getattr("timezone")
+            .unwrap()
+            .getattr("utc")
+            .unwrap()
+    }
 
-//     #[cfg(not(any(target_arch = "wasm32", Py_GIL_DISABLED)))]
-//     mod proptests {
-//         use super::*;
-//         use crate::tests::common::CatchWarnings;
-//         use crate::types::IntoPyDict;
-//         use proptest::prelude::*;
-//         use std::ffi::CString;
-
-//         proptest! {
-
-//             // Range is limited to 1970 to 2038 due to windows limitations
-//             #[test]
-//             fn test_pyo3_offset_fixed_frompyobject_created_in_python(timestamp in 0..(i32::MAX as i64), timedelta in -86399i32..=86399i32) {
-//                 Python::with_gil(|py| {
-
-//                     let globals = [("datetime", py.import("datetime").unwrap())].into_py_dict(py).unwrap();
-//                     let code = format!("datetime.datetime.fromtimestamp({}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={})))", timestamp, timedelta);
-//                     let t = py.eval(&CString::new(code).unwrap(), Some(&globals), None).unwrap();
-
-//                     // Get ISO 8601 string from python
-//                     let py_iso_str = t.call_method0("isoformat").unwrap();
-
-//                     // Get ISO 8601 string from rust
-//                     let t = t.extract::<OffsetDateTime<FixedOffset>>().unwrap();
-//                     // Python doesn't print the seconds of the offset if they are 0
-//                     let rust_iso_str = if timedelta % 60 == 0 {
-//                         t.format("%Y-%m-%dT%H:%M:%S%:z").to_string()
-//                     } else {
-//                         t.format("%Y-%m-%dT%H:%M:%S%::z").to_string()
-//                     };
-
-//                     // They should be equal
-//                     assert_eq!(py_iso_str.to_string(), rust_iso_str);
-//                 })
-//             }
-
-//             #[test]
-//             fn test_duration_roundtrip(days in -999999999i64..=999999999i64) {
-//                 // Test roundtrip conversion rust->python->rust for all allowed
-//                 // python values of durations (from -999999999 to 999999999 days),
-//                 Python::with_gil(|py| {
-//                     let dur = Duration::days(days);
-//                     let py_delta = dur.into_pyobject(py).unwrap();
-//                     let roundtripped: Duration = py_delta.extract().expect("Round trip");
-//                     assert_eq!(dur, roundtripped);
-//                 })
-//             }
-
-//             #[test]
-//             fn test_fixed_offset_roundtrip(secs in -86399i32..=86399i32) {
-//                 Python::with_gil(|py| {
-//                     let offset = FixedOffset::east_opt(secs).unwrap();
-//                     let py_offset = offset.into_pyobject(py).unwrap();
-//                     let roundtripped: FixedOffset = py_offset.extract().expect("Round trip");
-//                     assert_eq!(offset, roundtripped);
-//                 })
-//             }
-
-//             #[test]
-//             fn test_naive_date_roundtrip(
-//                 year in 1i32..=9999i32,
-//                 month in 1u32..=12u32,
-//                 day in 1u32..=31u32
-//             ) {
-//                 // Test roundtrip conversion rust->python->rust for all allowed
-//                 // python dates (from year 1 to year 9999)
-//                 Python::with_gil(|py| {
-//                     // We use to `from_ymd_opt` constructor so that we only test valid `Date`s.
-//                     // This is to skip the test if we are creating an invalid date, like February 31.
-//                     if let Some(date) = Date::from_ymd_opt(year, month, day) {
-//                         let py_date = date.into_pyobject(py).unwrap();
-//                         let roundtripped: Date = py_date.extract().expect("Round trip");
-//                         assert_eq!(date, roundtripped);
-//                     }
-//                 })
-//             }
-
-//             #[test]
-//             fn test_naive_time_roundtrip(
-//                 hour in 0u32..=23u32,
-//                 min in 0u32..=59u32,
-//                 sec in 0u32..=59u32,
-//                 micro in 0u32..=1_999_999u32
-//             ) {
-//                 // Test roundtrip conversion rust->python->rust for naive times.
-//                 // Python time has a resolution of microseconds, so we only test
-//                 // NaiveTimes with microseconds resolution, even if Time has nanosecond
-//                 // resolution.
-//                 Python::with_gil(|py| {
-//                     if let Some(time) = Time::from_hms_micro_opt(hour, min, sec, micro) {
-//                         // Wrap in CatchWarnings to avoid to_object firing warning for truncated leap second
-//                         let py_time = CatchWarnings::enter(py, |_| time.into_pyobject(py)).unwrap();
-//                         let roundtripped: Time = py_time.extract().expect("Round trip");
-//                         // Leap seconds are not roundtripped
-//                         let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| Time::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
-//                         assert_eq!(expected_roundtrip_time, roundtripped);
-//                     }
-//                 })
-//             }
-
-//             #[test]
-//             fn test_naive_datetime_roundtrip(
-//                 year in 1i32..=9999i32,
-//                 month in 1u32..=12u32,
-//                 day in 1u32..=31u32,
-//                 hour in 0u32..=24u32,
-//                 min in 0u32..=60u32,
-//                 sec in 0u32..=60u32,
-//                 micro in 0u32..=999_999u32
-//             ) {
-//                 Python::with_gil(|py| {
-//                     let date_opt = Date::from_ymd_opt(year, month, day);
-//                     let time_opt = Time::from_hms_micro_opt(hour, min, sec, micro);
-//                     if let (Some(date), Some(time)) = (date_opt, time_opt) {
-//                         let dt = PrimitiveDateTime::new(date, time);
-//                         let pydt = dt.into_pyobject(py).unwrap();
-//                         let roundtripped: PrimitiveDateTime = pydt.extract().expect("Round trip");
-//                         assert_eq!(dt, roundtripped);
-//                     }
-//                 })
-//             }
-
-//             #[test]
-//             fn test_utc_datetime_roundtrip(
-//                 year in 1i32..=9999i32,
-//                 month in 1u32..=12u32,
-//                 day in 1u32..=31u32,
-//                 hour in 0u32..=23u32,
-//                 min in 0u32..=59u32,
-//                 sec in 0u32..=59u32,
-//                 micro in 0u32..=1_999_999u32
-//             ) {
-//                 Python::with_gil(|py| {
-//                     let date_opt = Date::from_ymd_opt(year, month, day);
-//                     let time_opt = Time::from_hms_micro_opt(hour, min, sec, micro);
-//                     if let (Some(date), Some(time)) = (date_opt, time_opt) {
-//                         let dt: OffsetDateTime<Utc> = PrimitiveDateTime::new(date, time).and_utc();
-//                         // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
-//                         let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
-//                         let roundtripped: OffsetDateTime<Utc> = py_dt.extract().expect("Round trip");
-//                         // Leap seconds are not roundtripped
-//                         let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| Time::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
-//                         let expected_roundtrip_dt: OffsetDateTime<Utc> = PrimitiveDateTime::new(date, expected_roundtrip_time).and_utc();
-//                         assert_eq!(expected_roundtrip_dt, roundtripped);
-//                     }
-//                 })
-//             }
-
-//             #[test]
-//             fn test_fixed_offset_datetime_roundtrip(
-//                 year in 1i32..=9999i32,
-//                 month in 1u32..=12u32,
-//                 day in 1u32..=31u32,
-//                 hour in 0u32..=23u32,
-//                 min in 0u32..=59u32,
-//                 sec in 0u32..=59u32,
-//                 micro in 0u32..=1_999_999u32,
-//                 offset_secs in -86399i32..=86399i32
-//             ) {
-//                 Python::with_gil(|py| {
-//                     let date_opt = Date::from_ymd_opt(year, month, day);
-//                     let time_opt = Time::from_hms_micro_opt(hour, min, sec, micro);
-//                     let offset = FixedOffset::east_opt(offset_secs).unwrap();
-//                     if let (Some(date), Some(time)) = (date_opt, time_opt) {
-//                         let dt: OffsetDateTime<FixedOffset> = PrimitiveDateTime::new(date, time).and_local_timezone(offset).unwrap();
-//                         // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
-//                         let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
-//                         let roundtripped: OffsetDateTime<FixedOffset> = py_dt.extract().expect("Round trip");
-//                         // Leap seconds are not roundtripped
-//                         let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| Time::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
-//                         let expected_roundtrip_dt: OffsetDateTime<FixedOffset> = PrimitiveDateTime::new(date, expected_roundtrip_time).and_local_timezone(offset).unwrap();
-//                         assert_eq!(expected_roundtrip_dt, roundtripped);
-//                     }
-//                 })
-//             }
-//         }
-//     }
-// }
+    // #[cfg(not(any(target_arch = "wasm32", Py_GIL_DISABLED)))]
+    // mod proptests {
+    //     use super::*;
+    //     use crate::tests::common::CatchWarnings;
+    //     use crate::types::IntoPyDict;
+    //     use proptest::prelude::*;
+    //     use std::ffi::CString;
+
+    //     proptest! {
+
+    //         // Range is limited to 1970 to 2038 due to windows limitations
+    //         #[test]
+    //         fn test_pyo3_offset_fixed_frompyobject_created_in_python(timestamp in 0..(i32::MAX as i64), timedelta in -86399i32..=86399i32) {
+    //             Python::with_gil(|py| {
+
+    //                 let globals = [("datetime", py.import("datetime").unwrap())].into_py_dict(py).unwrap();
+    //                 let code = format!("datetime.datetime.fromtimestamp({}).replace(tzinfo=datetime.timezone(datetime.timedelta(seconds={})))", timestamp, timedelta);
+    //                 let t = py.eval(&CString::new(code).unwrap(), Some(&globals), None).unwrap();
+
+    //                 // Get ISO 8601 string from python
+    //                 let py_iso_str = t.call_method0("isoformat").unwrap();
+
+    //                 // Get ISO 8601 string from rust
+    //                 let t = t.extract::<OffsetDateTime<FixedOffset>>().unwrap();
+    //                 // Python doesn't print the seconds of the offset if they are 0
+    //                 let rust_iso_str = if timedelta % 60 == 0 {
+    //                     t.format("%Y-%m-%dT%H:%M:%S%:z").to_string()
+    //                 } else {
+    //                     t.format("%Y-%m-%dT%H:%M:%S%::z").to_string()
+    //                 };
+
+    //                 // They should be equal
+    //                 assert_eq!(py_iso_str.to_string(), rust_iso_str);
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_duration_roundtrip(days in -999999999i64..=999999999i64) {
+    //             // Test roundtrip conversion rust->python->rust for all allowed
+    //             // python values of durations (from -999999999 to 999999999 days),
+    //             Python::with_gil(|py| {
+    //                 let dur = Duration::days(days);
+    //                 let py_delta = dur.into_pyobject(py).unwrap();
+    //                 let roundtripped: Duration = py_delta.extract().expect("Round trip");
+    //                 assert_eq!(dur, roundtripped);
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_fixed_offset_roundtrip(secs in -86399i32..=86399i32) {
+    //             Python::with_gil(|py| {
+    //                 let offset = FixedOffset::east_opt(secs).unwrap();
+    //                 let py_offset = offset.into_pyobject(py).unwrap();
+    //                 let roundtripped: FixedOffset = py_offset.extract().expect("Round trip");
+    //                 assert_eq!(offset, roundtripped);
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_naive_date_roundtrip(
+    //             year in 1i32..=9999i32,
+    //             month in 1u32..=12u32,
+    //             day in 1u32..=31u32
+    //         ) {
+    //             // Test roundtrip conversion rust->python->rust for all allowed
+    //             // python dates (from year 1 to year 9999)
+    //             Python::with_gil(|py| {
+    //                 // We use to `from_ymd_opt` constructor so that we only test valid `Date`s.
+    //                 // This is to skip the test if we are creating an invalid date, like February 31.
+    //                 if let Some(date) = Date::from_ymd_opt(year, month, day) {
+    //                     let py_date = date.into_pyobject(py).unwrap();
+    //                     let roundtripped: Date = py_date.extract().expect("Round trip");
+    //                     assert_eq!(date, roundtripped);
+    //                 }
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_naive_time_roundtrip(
+    //             hour in 0u32..=23u32,
+    //             min in 0u32..=59u32,
+    //             sec in 0u32..=59u32,
+    //             micro in 0u32..=1_999_999u32
+    //         ) {
+    //             // Test roundtrip conversion rust->python->rust for naive times.
+    //             // Python time has a resolution of microseconds, so we only test
+    //             // NaiveTimes with microseconds resolution, even if Time has nanosecond
+    //             // resolution.
+    //             Python::with_gil(|py| {
+    //                 if let Some(time) = Time::from_hms_micro_opt(hour, min, sec, micro) {
+    //                     // Wrap in CatchWarnings to avoid to_object firing warning for truncated leap second
+    //                     let py_time = CatchWarnings::enter(py, |_| time.into_pyobject(py)).unwrap();
+    //                     let roundtripped: Time = py_time.extract().expect("Round trip");
+    //                     // Leap seconds are not roundtripped
+    //                     let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| Time::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
+    //                     assert_eq!(expected_roundtrip_time, roundtripped);
+    //                 }
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_naive_datetime_roundtrip(
+    //             year in 1i32..=9999i32,
+    //             month in 1u32..=12u32,
+    //             day in 1u32..=31u32,
+    //             hour in 0u32..=24u32,
+    //             min in 0u32..=60u32,
+    //             sec in 0u32..=60u32,
+    //             micro in 0u32..=999_999u32
+    //         ) {
+    //             Python::with_gil(|py| {
+    //                 let date_opt = Date::from_ymd_opt(year, month, day);
+    //                 let time_opt = Time::from_hms_micro_opt(hour, min, sec, micro);
+    //                 if let (Some(date), Some(time)) = (date_opt, time_opt) {
+    //                     let dt = PrimitiveDateTime::new(date, time);
+    //                     let pydt = dt.into_pyobject(py).unwrap();
+    //                     let roundtripped: PrimitiveDateTime = pydt.extract().expect("Round trip");
+    //                     assert_eq!(dt, roundtripped);
+    //                 }
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_utc_datetime_roundtrip(
+    //             year in 1i32..=9999i32,
+    //             month in 1u32..=12u32,
+    //             day in 1u32..=31u32,
+    //             hour in 0u32..=23u32,
+    //             min in 0u32..=59u32,
+    //             sec in 0u32..=59u32,
+    //             micro in 0u32..=1_999_999u32
+    //         ) {
+    //             Python::with_gil(|py| {
+    //                 let date_opt = Date::from_ymd_opt(year, month, day);
+    //                 let time_opt = Time::from_hms_micro_opt(hour, min, sec, micro);
+    //                 if let (Some(date), Some(time)) = (date_opt, time_opt) {
+    //                     let dt: OffsetDateTime<Utc> = PrimitiveDateTime::new(date, time).and_utc();
+    //                     // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
+    //                     let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
+    //                     let roundtripped: OffsetDateTime<Utc> = py_dt.extract().expect("Round trip");
+    //                     // Leap seconds are not roundtripped
+    //                     let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| Time::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
+    //                     let expected_roundtrip_dt: OffsetDateTime<Utc> = PrimitiveDateTime::new(date, expected_roundtrip_time).and_utc();
+    //                     assert_eq!(expected_roundtrip_dt, roundtripped);
+    //                 }
+    //             })
+    //         }
+
+    //         #[test]
+    //         fn test_fixed_offset_datetime_roundtrip(
+    //             year in 1i32..=9999i32,
+    //             month in 1u32..=12u32,
+    //             day in 1u32..=31u32,
+    //             hour in 0u32..=23u32,
+    //             min in 0u32..=59u32,
+    //             sec in 0u32..=59u32,
+    //             micro in 0u32..=1_999_999u32,
+    //             offset_secs in -86399i32..=86399i32
+    //         ) {
+    //             Python::with_gil(|py| {
+    //                 let date_opt = Date::from_ymd_opt(year, month, day);
+    //                 let time_opt = Time::from_hms_micro_opt(hour, min, sec, micro);
+    //                 let offset = FixedOffset::east_opt(offset_secs).unwrap();
+    //                 if let (Some(date), Some(time)) = (date_opt, time_opt) {
+    //                     let dt: OffsetDateTime<FixedOffset> = PrimitiveDateTime::new(date, time).and_local_timezone(offset).unwrap();
+    //                     // Wrap in CatchWarnings to avoid into_py firing warning for truncated leap second
+    //                     let py_dt = CatchWarnings::enter(py, |_| dt.into_pyobject(py)).unwrap();
+    //                     let roundtripped: OffsetDateTime<FixedOffset> = py_dt.extract().expect("Round trip");
+    //                     // Leap seconds are not roundtripped
+    //                     let expected_roundtrip_time = micro.checked_sub(1_000_000).map(|micro| Time::from_hms_micro_opt(hour, min, sec, micro).unwrap()).unwrap_or(time);
+    //                     let expected_roundtrip_dt: OffsetDateTime<FixedOffset> = PrimitiveDateTime::new(date, expected_roundtrip_time).and_local_timezone(offset).unwrap();
+    //                     assert_eq!(expected_roundtrip_dt, roundtripped);
+    //                 }
+    //             })
+    //         }
+    //     }
+    // }
+}