fix: final bits, hopefully ok

Author: ollz272

src/input/datetime.rs

@@ -113,27 +113,21 @@ impl<'a> EitherTimedelta<'a> {
     pub fn total_seconds(&self) -> PyResult<f64> {
         match self {
             Self::Raw(timedelta) => {
-                let mut days: f64 = timedelta.day as f64;
-                let mut seconds: f64 = timedelta.second as f64;
-                let mut microseconds: f64 = timedelta.microsecond as f64;
-                let mut total_seconds: f64 = if !timedelta.positive {
+                let days: f64 = f64::from(timedelta.day);
+                let seconds: f64 = f64::from(timedelta.second);
+                let microseconds: f64 = f64::from(timedelta.microsecond);
+                let total_seconds: f64 = if !timedelta.positive {
                     -1.0 * (86400.0 * days + seconds + microseconds / 1_000_000.0)
                 } else {
                     86400.0 * days + seconds + microseconds / 1_000_000.0
                 };
                 Ok(total_seconds)
             }
             Self::PyExact(py_timedelta) => {
-                let mut days: f64 = py_timedelta.get_days() as f64; // -999999999 to 999999999
-                let mut seconds: f64 = py_timedelta.get_seconds() as f64; // 0 through 86399
-                let mut microseconds: f64 = py_timedelta.get_microseconds() as f64; // 0 through 999999
-                let positive = days >= 0.0;
-                let total_seconds: f64 = if !positive {
-                    86400.0 * days + seconds + microseconds / 1_000_000.0
-                } else {
-                    86400.0 * days + seconds + microseconds / 1_000_000.0
-                };
-                Ok(total_seconds)
+                let days: f64 = f64::from(py_timedelta.get_days()); // -999999999 to 999999999
+                let seconds: f64 = f64::from(py_timedelta.get_seconds()); // 0 through 86399
+                let microseconds: f64 = f64::from(py_timedelta.get_microseconds()); // 0 through 999999
+                Ok(86400.0 * days + seconds + microseconds / 1_000_000.0)
             }
             Self::PySubclass(py_timedelta) => {
                 let total_seconds: f64 = py_timedelta

src/serializers/config.rs

@@ -4,7 +4,7 @@ use std::str::{from_utf8, FromStr, Utf8Error};
 use base64::Engine;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDelta, PyDict, PyFloat, PyString};
+use pyo3::types::{PyDict, PyFloat, PyString};
 
 use serde::ser::Error;
 
@@ -132,7 +132,7 @@ impl TimedeltaMode {
         }
     }
 
-    pub fn json_key<'py>(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
+    pub fn json_key<'py>(self, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
@@ -152,7 +152,6 @@ impl TimedeltaMode {
 
     pub fn timedelta_serialize<S: serde::ser::Serializer>(
         self,
-        py: Python,
         either_delta: &EitherTimedelta,
         serializer: S,
     ) -> Result<S::Ok, S::Error> {

src/serializers/infer.rs

@@ -477,7 +477,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             extra
                 .config
                 .timedelta_mode
-                .timedelta_serialize(value.py(), &either_delta, serializer)
+                .timedelta_serialize(&either_delta, serializer)
         }
         ObType::Url => {
             let py_url: PyUrl = value.extract().map_err(py_err_se_err)?;
@@ -655,7 +655,7 @@ pub(crate) fn infer_json_key_known<'a>(
         }
         ObType::Timedelta => {
             let either_delta = EitherTimedelta::try_from(key)?;
-            extra.config.timedelta_mode.json_key(key.py(), &either_delta)
+            extra.config.timedelta_mode.json_key(&either_delta)
         }
         ObType::Url => {
             let py_url: PyUrl = key.extract()?;

src/serializers/type_serializers/timedelta.rs

@@ -54,7 +54,7 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
-            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
+            Ok(either_timedelta) => self.timedelta_mode.json_key(&either_timedelta),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -71,9 +71,7 @@ impl TypeSerializer for TimeDeltaSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
-            Ok(either_timedelta) => self
-                .timedelta_mode
-                .timedelta_serialize(value.py(), &either_timedelta, serializer),
+            Ok(either_timedelta) => self.timedelta_mode.timedelta_serialize(&either_timedelta, serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)