fix: fix precision issues using davids method

Author: ollz272

src/input/datetime.rs

@@ -113,21 +113,38 @@ impl<'a> EitherTimedelta<'a> {
     pub fn total_seconds(&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 * (86400.0 * days + seconds + microseconds / 1_000_000.0)
+                let mut days: i64 = i64::from(timedelta.day);
+                let mut seconds: i64 = i64::from(timedelta.second);
+                let mut microseconds = i64::from(timedelta.microsecond);
+                if !timedelta.positive {
+                    days = -days;
+                    seconds = -seconds;
+                    microseconds = -microseconds;
+                }
+
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + microseconds;
+                    Ok(total_microseconds as f64 / 1_000_000.0)
                 } else {
-                    86400.0 * days + seconds + microseconds / 1_000_000.0
-                };
-                Ok(total_seconds)
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000_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(86400.0 * days + seconds + microseconds / 1_000_000.0)
+                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
+                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
+                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
+                    Ok(total_microseconds as f64 / 1_000_000.0)
+                } else {
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_seconds = days_seconds as f64 + f64::from(microseconds) / 1_000_000.0;
+                    Ok(total_seconds)
+                }
             }
             Self::PySubclass(py_timedelta) => py_timedelta
                 .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
@@ -138,28 +155,45 @@ impl<'a> EitherTimedelta<'a> {
     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)
+                let mut days: i64 = i64::from(timedelta.day);
+                let mut seconds: i64 = i64::from(timedelta.second);
+                let mut microseconds = i64::from(timedelta.microsecond);
+                if !timedelta.positive {
+                    days = -days;
+                    seconds = -seconds;
+                    microseconds = -microseconds;
+                }
+
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + microseconds;
+                    Ok(total_microseconds as f64 / 1_000.0)
                 } else {
-                    86_400_000.0 * days + seconds * 1_000.0 + microseconds / 1_000.0
-                };
-                Ok(total_seconds)
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_seconds = days_seconds as f64 + microseconds as f64 / 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)
+                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
+                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
+                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
+                    Ok(total_microseconds as f64 / 1_000.0)
+                } else {
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_milliseconds = days_seconds as f64 * 1_000.0 + f64::from(microseconds) / 1_000.0;
+                    Ok(total_milliseconds)
+                }
             }
             Self::PySubclass(py_timedelta) => {
-                let total_seconds = py_timedelta
+                let total_seconds: f64 = py_timedelta
                     .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
                     .extract()?;
                 Ok(total_seconds / 1000.0)
-            },
+            }
         }
     }
 }

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.0009999999999763531,
-            b'-0.0009999999999763531',
-            {'-0.0009999999999763531': 'foo'},
-            b'{"-0.0009999999999763531":"foo"}',
+            -0.001,
+            b'-0.001',
+            {'-0.001': 'foo'},
+            b'{"-0.001":"foo"}',
             'milliseconds_float',
         ),
         (
@@ -263,10 +263,10 @@ def test_any_with_timedelta_serializer():
         (timedelta(microseconds=1), 1e-6, b'1e-6', {'0.000001': 'foo'}, b'{"0.000001":"foo"}', 'seconds_float'),
         (
             timedelta(microseconds=-1),
-            -1.0000000000287557e-6,
-            b'-1.0000000000287557e-6',
-            {'-0.0000010000000000287557': 'foo'},
-            b'{"-0.0000010000000000287557":"foo"}',
+            -1e-6,
+            b'-1e-6',
+            {'-0.000001': 'foo'},
+            b'{"-0.000001":"foo"}',
             'seconds_float',
         ),
         (timedelta(days=1), 86400.0, b'86400.0', {'86400': 'foo'}, b'{"86400":"foo"}', 'seconds_float'),