fix: some floating point bits

Author: ollz272

src/input/datetime.rs

@@ -134,6 +134,31 @@ impl<'a> EitherTimedelta<'a> {
                 .extract(),
         }
     }
+
+    pub fn total_milliseconds(&self) -> PyResult<f64> {
+        match self {
+            Self::Raw(timedelta) => {
+                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 * (86_400_000.0 * days + seconds * 1_000.0 + microseconds / 1_000.0)
+                } else {
+                    86_400_000.0 * days + seconds * 1_000.0 + microseconds / 1_000.0
+                };
+                Ok(total_seconds)
+            }
+            Self::PyExact(py_timedelta) => {
+                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(86_400_000.0 * days + seconds * 1_000.0 + microseconds / 1_000.0)
+            }
+            Self::PySubclass(py_timedelta) => py_timedelta
+                .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
+                .extract(),
+        }
+    }
 }
 
 impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {

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::{PyDict, PyFloat, PyString};
+use pyo3::types::{PyDict, PyString};
 
 use serde::ser::Error;
 
@@ -120,9 +120,8 @@ impl TimedeltaMode {
                 Ok(seconds.into_py(py))
             }
             Self::MillisecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds()?;
-                let object: Bound<PyFloat> = PyFloat::new_bound(py, seconds * 1000.0);
-                Ok(object.into_py(py))
+                let milliseconds: f64 = either_delta.total_milliseconds()?;
+                Ok(milliseconds.into_py(py))
             }
         }
     }
@@ -138,8 +137,7 @@ impl TimedeltaMode {
                 Ok(seconds.to_string().into())
             }
             Self::MillisecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds()?;
-                let milliseconds: f64 = seconds * 1000.0;
+                let milliseconds: f64 = either_delta.total_milliseconds()?;
                 Ok(milliseconds.to_string().into())
             }
         }
@@ -160,8 +158,7 @@ impl TimedeltaMode {
                 serializer.serialize_f64(seconds)
             }
             Self::MillisecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds().map_err(py_err_se_err)?;
-                let milliseconds: f64 = seconds * 1000.0;
+                let milliseconds: f64 = either_delta.total_milliseconds().map_err(py_err_se_err)?;
                 serializer.serialize_f64(milliseconds)
             }
         }

tests/serializers/test_any.py

@@ -194,10 +194,10 @@ def test_any_with_timedelta_serializer():
         (timedelta(microseconds=1), 0.001, b'0.001', {'0.001': 'foo'}, b'{"0.001":"foo"}', 'milliseconds_float'),
         (
             timedelta(microseconds=-1),
-            -0.0010000000000287557,
-            b'-0.0010000000000287557',
-            {'-0.0010000000000287557': 'foo'},
-            b'{"-0.0010000000000287557":"foo"}',
+            -0.0009999999999763531,
+            b'-0.0009999999999763531',
+            {'-0.0009999999999763531': 'foo'},
+            b'{"-0.0009999999999763531":"foo"}',
             'milliseconds_float',
         ),
         (
@@ -242,18 +242,18 @@ def test_any_with_timedelta_serializer():
         ),
         (
             timedelta(days=1, seconds=1, microseconds=1),
-            86401000.00099999,
-            b'86401000.00099999',
-            {'86401000.00099999': 'foo'},
-            b'{"86401000.00099999":"foo"}',
+            86401000.001,
+            b'86401000.001',
+            {'86401000.001': 'foo'},
+            b'{"86401000.001":"foo"}',
             'milliseconds_float',
         ),
         (
             timedelta(days=-1, seconds=-1, microseconds=-1),
-            -86401000.00099999,
-            b'-86401000.00099999',
-            {'-86401000.00099999': 'foo'},
-            b'{"-86401000.00099999":"foo"}',
+            -86401000.001,
+            b'-86401000.001',
+            {'-86401000.001': 'foo'},
+            b'{"-86401000.001":"foo"}',
             'milliseconds_float',
         ),
         (timedelta(hours=2), 7200.0, b'7200.0', {'7200': 'foo'}, b'{"7200":"foo"}', 'seconds_float'),