1use crate::conversion::IntoPyObject;
2use crate::exceptions::{PyOverflowError, PyValueError};
3use crate::sync::GILOnceCell;
4use crate::types::any::PyAnyMethods;
5#[cfg(Py_LIMITED_API)]
6use crate::types::PyType;
7#[cfg(not(Py_LIMITED_API))]
8use crate::types::{timezone_utc, PyDateTime, PyDelta, PyDeltaAccess};
9#[cfg(Py_LIMITED_API)]
10use crate::Py;
11use crate::{intern, Bound, FromPyObject, PyAny, PyErr, PyObject, PyResult, Python};
12#[allow(deprecated)]
13use crate::{IntoPy, ToPyObject};
14use std::time::{Duration, SystemTime, UNIX_EPOCH};
15
16const SECONDS_PER_DAY: u64 = 24 * 60 * 60;
17
18impl FromPyObject<'_> for Duration {
19 fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
20 #[cfg(not(Py_LIMITED_API))]
21 let (days, seconds, microseconds) = {
22 let delta = obj.downcast::<PyDelta>()?;
23 (
24 delta.get_days(),
25 delta.get_seconds(),
26 delta.get_microseconds(),
27 )
28 };
29 #[cfg(Py_LIMITED_API)]
30 let (days, seconds, microseconds): (i32, i32, i32) = {
31 (
32 obj.getattr(intern!(obj.py(), "days"))?.extract()?,
33 obj.getattr(intern!(obj.py(), "seconds"))?.extract()?,
34 obj.getattr(intern!(obj.py(), "microseconds"))?.extract()?,
35 )
36 };
37
38 // We cast
39 let days = u64::try_from(days).map_err(|_| {
40 PyValueError::new_err(
41 "It is not possible to convert a negative timedelta to a Rust Duration",
42 )
43 })?;
44 let seconds = u64::try_from(seconds).unwrap(); // 0 <= seconds < 3600*24
45 let microseconds = u32::try_from(microseconds).unwrap(); // 0 <= microseconds < 1000000
46
47 // We convert
48 let total_seconds = days * SECONDS_PER_DAY + seconds; // We casted from i32, this can't overflow
49 let nanoseconds = microseconds.checked_mul(1_000).unwrap(); // 0 <= microseconds < 1000000
50
51 Ok(Duration::new(total_seconds, nanoseconds))
52 }
53}
54
55#[allow(deprecated)]
56impl ToPyObject for Duration {
57 #[inline]
58 fn to_object(&self, py: Python<'_>) -> PyObject {
59 self.into_pyobject(py).unwrap().into_any().unbind()
60 }
61}
62
63#[allow(deprecated)]
64impl IntoPy<PyObject> for Duration {
65 #[inline]
66 fn into_py(self, py: Python<'_>) -> PyObject {
67 self.into_pyobject(py).unwrap().into_any().unbind()
68 }
69}
70
71impl<'py> IntoPyObject<'py> for Duration {
72 #[cfg(not(Py_LIMITED_API))]
73 type Target = PyDelta;
74 #[cfg(Py_LIMITED_API)]
75 type Target = PyAny;
76 type Output = Bound<'py, Self::Target>;
77 type Error = PyErr;
78
79 fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
80 let days = self.as_secs() / SECONDS_PER_DAY;
81 let seconds = self.as_secs() % SECONDS_PER_DAY;
82 let microseconds = self.subsec_micros();
83
84 #[cfg(not(Py_LIMITED_API))]
85 {
86 PyDelta::new(
87 py,
88 days.try_into()?,
89 seconds.try_into().unwrap(),
90 microseconds.try_into().unwrap(),
91 false,
92 )
93 }
94 #[cfg(Py_LIMITED_API)]
95 {
96 static TIMEDELTA: GILOnceCell<Py<PyType>> = GILOnceCell::new();
97 TIMEDELTA
98 .import(py, "datetime", "timedelta")?
99 .call1((days, seconds, microseconds))
100 }
101 }
102}
103
104impl<'py> IntoPyObject<'py> for &Duration {
105 #[cfg(not(Py_LIMITED_API))]
106 type Target = PyDelta;
107 #[cfg(Py_LIMITED_API)]
108 type Target = PyAny;
109 type Output = Bound<'py, Self::Target>;
110 type Error = PyErr;
111
112 #[inline]
113 fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
114 (*self).into_pyobject(py)
115 }
116}
117
118// Conversions between SystemTime and datetime do not rely on the floating point timestamp of the
119// timestamp/fromtimestamp APIs to avoid possible precision loss but goes through the
120// timedelta/std::time::Duration types by taking for reference point the UNIX epoch.
121//
122// TODO: it might be nice to investigate using timestamps anyway, at least when the datetime is a safe range.
123
124impl FromPyObject<'_> for SystemTime {
125 fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
126 let duration_since_unix_epoch: Duration = objBound<'_, PyAny>
127 .call_method1(name:intern!(obj.py(), "__sub__"), (unix_epoch_py(obj.py())?,))?
128 .extract()?;
129 UNIX_EPOCH
130 .checked_add(duration_since_unix_epoch)
131 .ok_or_else(|| {
132 PyOverflowError::new_err(args:"Overflow error when converting the time to Rust")
133 })
134 }
135}
136
137#[allow(deprecated)]
138impl ToPyObject for SystemTime {
139 #[inline]
140 fn to_object(&self, py: Python<'_>) -> PyObject {
141 self.into_pyobject(py).unwrap().into_any().unbind()
142 }
143}
144
145#[allow(deprecated)]
146impl IntoPy<PyObject> for SystemTime {
147 #[inline]
148 fn into_py(self, py: Python<'_>) -> PyObject {
149 self.into_pyobject(py).unwrap().into_any().unbind()
150 }
151}
152
153impl<'py> IntoPyObject<'py> for SystemTime {
154 type Target = PyAny;
155 type Output = Bound<'py, Self::Target>;
156 type Error = PyErr;
157
158 fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
159 let duration_since_unix_epoch: Bound<'_, PyAny> =
160 self.duration_since(UNIX_EPOCH).unwrap().into_pyobject(py)?;
161 unix_epoch_py(py)?
162 .bind(py)
163 .call_method1(name:intern!(py, "__add__"), (duration_since_unix_epoch,))
164 }
165}
166
167impl<'py> IntoPyObject<'py> for &SystemTime {
168 type Target = PyAny;
169 type Output = Bound<'py, Self::Target>;
170 type Error = PyErr;
171
172 #[inline]
173 fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
174 (*self).into_pyobject(py)
175 }
176}
177
178fn unix_epoch_py(py: Python<'_>) -> PyResult<&PyObject> {
179 static UNIX_EPOCH: GILOnceCell<PyObject> = GILOnceCell::new();
180 UNIX_EPOCH.get_or_try_init(py, || {
181 #[cfg(not(Py_LIMITED_API))]
182 {
183 Ok::<_, PyErr>(
184 PyDateTime::new(py, 1970, 1, 1, 0, 0, 0, 0, Some(&timezone_utc(py)))?.into(),
185 )
186 }
187 #[cfg(Py_LIMITED_API)]
188 {
189 let datetime: Bound<'_, PyModule> = py.import(name:"datetime")?;
190 let utc: Bound<'_, PyAny> = datetime.getattr("timezone")?.getattr(attr_name:"utc")?;
191 Ok::<_, PyErr>(
192 datetimeBound<'_, PyAny>
193 .getattr("datetime")?
194 .call1((1970, 1, 1, 0, 0, 0, 0, utc))
195 .unwrap()
196 .into(),
197 )
198 }
199 })
200}
201
202#[cfg(test)]
203mod tests {
204 use super::*;
205 use crate::types::PyDict;
206
207 #[test]
208 fn test_duration_frompyobject() {
209 Python::with_gil(|py| {
210 assert_eq!(
211 new_timedelta(py, 0, 0, 0).extract::<Duration>().unwrap(),
212 Duration::new(0, 0)
213 );
214 assert_eq!(
215 new_timedelta(py, 1, 0, 0).extract::<Duration>().unwrap(),
216 Duration::new(86400, 0)
217 );
218 assert_eq!(
219 new_timedelta(py, 0, 1, 0).extract::<Duration>().unwrap(),
220 Duration::new(1, 0)
221 );
222 assert_eq!(
223 new_timedelta(py, 0, 0, 1).extract::<Duration>().unwrap(),
224 Duration::new(0, 1_000)
225 );
226 assert_eq!(
227 new_timedelta(py, 1, 1, 1).extract::<Duration>().unwrap(),
228 Duration::new(86401, 1_000)
229 );
230 assert_eq!(
231 timedelta_class(py)
232 .getattr("max")
233 .unwrap()
234 .extract::<Duration>()
235 .unwrap(),
236 Duration::new(86399999999999, 999999000)
237 );
238 });
239 }
240
241 #[test]
242 fn test_duration_frompyobject_negative() {
243 Python::with_gil(|py| {
244 assert_eq!(
245 new_timedelta(py, 0, -1, 0)
246 .extract::<Duration>()
247 .unwrap_err()
248 .to_string(),
249 "ValueError: It is not possible to convert a negative timedelta to a Rust Duration"
250 );
251 })
252 }
253
254 #[test]
255 fn test_duration_into_pyobject() {
256 Python::with_gil(|py| {
257 let assert_eq = |l: Bound<'_, PyAny>, r: Bound<'_, PyAny>| {
258 assert!(l.eq(r).unwrap());
259 };
260
261 assert_eq(
262 Duration::new(0, 0).into_pyobject(py).unwrap().into_any(),
263 new_timedelta(py, 0, 0, 0),
264 );
265 assert_eq(
266 Duration::new(86400, 0)
267 .into_pyobject(py)
268 .unwrap()
269 .into_any(),
270 new_timedelta(py, 1, 0, 0),
271 );
272 assert_eq(
273 Duration::new(1, 0).into_pyobject(py).unwrap().into_any(),
274 new_timedelta(py, 0, 1, 0),
275 );
276 assert_eq(
277 Duration::new(0, 1_000)
278 .into_pyobject(py)
279 .unwrap()
280 .into_any(),
281 new_timedelta(py, 0, 0, 1),
282 );
283 assert_eq(
284 Duration::new(0, 1).into_pyobject(py).unwrap().into_any(),
285 new_timedelta(py, 0, 0, 0),
286 );
287 assert_eq(
288 Duration::new(86401, 1_000)
289 .into_pyobject(py)
290 .unwrap()
291 .into_any(),
292 new_timedelta(py, 1, 1, 1),
293 );
294 assert_eq(
295 Duration::new(86399999999999, 999999000)
296 .into_pyobject(py)
297 .unwrap()
298 .into_any(),
299 timedelta_class(py).getattr("max").unwrap(),
300 );
301 });
302 }
303
304 #[test]
305 fn test_duration_into_pyobject_overflow() {
306 Python::with_gil(|py| {
307 assert!(Duration::MAX.into_pyobject(py).is_err());
308 })
309 }
310
311 #[test]
312 fn test_time_frompyobject() {
313 Python::with_gil(|py| {
314 assert_eq!(
315 new_datetime(py, 1970, 1, 1, 0, 0, 0, 0)
316 .extract::<SystemTime>()
317 .unwrap(),
318 UNIX_EPOCH
319 );
320 assert_eq!(
321 new_datetime(py, 2020, 2, 3, 4, 5, 6, 7)
322 .extract::<SystemTime>()
323 .unwrap(),
324 UNIX_EPOCH
325 .checked_add(Duration::new(1580702706, 7000))
326 .unwrap()
327 );
328 assert_eq!(
329 max_datetime(py).extract::<SystemTime>().unwrap(),
330 UNIX_EPOCH
331 .checked_add(Duration::new(253402300799, 999999000))
332 .unwrap()
333 );
334 });
335 }
336
337 #[test]
338 fn test_time_frompyobject_before_epoch() {
339 Python::with_gil(|py| {
340 assert_eq!(
341 new_datetime(py, 1950, 1, 1, 0, 0, 0, 0)
342 .extract::<SystemTime>()
343 .unwrap_err()
344 .to_string(),
345 "ValueError: It is not possible to convert a negative timedelta to a Rust Duration"
346 );
347 })
348 }
349
350 #[test]
351 fn test_time_intopyobject() {
352 Python::with_gil(|py| {
353 let assert_eq = |l: Bound<'_, PyAny>, r: Bound<'_, PyAny>| {
354 assert!(l.eq(r).unwrap());
355 };
356
357 assert_eq(
358 UNIX_EPOCH
359 .checked_add(Duration::new(1580702706, 7123))
360 .unwrap()
361 .into_pyobject(py)
362 .unwrap(),
363 new_datetime(py, 2020, 2, 3, 4, 5, 6, 7),
364 );
365 assert_eq(
366 UNIX_EPOCH
367 .checked_add(Duration::new(253402300799, 999999000))
368 .unwrap()
369 .into_pyobject(py)
370 .unwrap(),
371 max_datetime(py),
372 );
373 });
374 }
375
376 #[allow(clippy::too_many_arguments)]
377 fn new_datetime(
378 py: Python<'_>,
379 year: i32,
380 month: u8,
381 day: u8,
382 hour: u8,
383 minute: u8,
384 second: u8,
385 microsecond: u32,
386 ) -> Bound<'_, PyAny> {
387 datetime_class(py)
388 .call1((
389 year,
390 month,
391 day,
392 hour,
393 minute,
394 second,
395 microsecond,
396 tz_utc(py),
397 ))
398 .unwrap()
399 }
400
401 fn max_datetime(py: Python<'_>) -> Bound<'_, PyAny> {
402 let naive_max = datetime_class(py).getattr("max").unwrap();
403 let kargs = PyDict::new(py);
404 kargs.set_item("tzinfo", tz_utc(py)).unwrap();
405 naive_max.call_method("replace", (), Some(&kargs)).unwrap()
406 }
407
408 #[test]
409 fn test_time_intopyobject_overflow() {
410 let big_system_time = UNIX_EPOCH
411 .checked_add(Duration::new(300000000000, 0))
412 .unwrap();
413 Python::with_gil(|py| {
414 assert!(big_system_time.into_pyobject(py).is_err());
415 })
416 }
417
418 fn tz_utc(py: Python<'_>) -> Bound<'_, PyAny> {
419 py.import("datetime")
420 .unwrap()
421 .getattr("timezone")
422 .unwrap()
423 .getattr("utc")
424 .unwrap()
425 }
426
427 fn new_timedelta(
428 py: Python<'_>,
429 days: i32,
430 seconds: i32,
431 microseconds: i32,
432 ) -> Bound<'_, PyAny> {
433 timedelta_class(py)
434 .call1((days, seconds, microseconds))
435 .unwrap()
436 }
437
438 fn datetime_class(py: Python<'_>) -> Bound<'_, PyAny> {
439 py.import("datetime").unwrap().getattr("datetime").unwrap()
440 }
441
442 fn timedelta_class(py: Python<'_>) -> Bound<'_, PyAny> {
443 py.import("datetime").unwrap().getattr("timedelta").unwrap()
444 }
445}
446