Expose NTP64 (#650)

* Expose NTP64

* Remove unused import

Author: wyfo

src/lib.rs

@@ -73,7 +73,7 @@ pub(crate) mod zenoh {
         sample::{Locality, Sample, SampleKind, SourceInfo},
         scouting::{scout, Hello, Scout},
         session::{open, EntityGlobalId, Session, SessionInfo},
-        time::{Timestamp, TimestampId},
+        time::{Timestamp, TimestampId, NTP64},
         ZError,
     };
 

src/time.rs

@@ -17,13 +17,14 @@ use std::{
 };
 
 use pyo3::{
+    exceptions::PyTypeError,
     prelude::*,
-    types::{PyBytes, PyType},
+    types::{PyBytes, PyDateTime, PyType},
 };
 
 use crate::{
     macros::{downcast_or_new, wrapper},
-    utils::IntoPyResult,
+    utils::{IntoPyErr, IntoPyResult},
 };
 
 wrapper!(zenoh::time::TimestampId: Copy, Clone, PartialEq, PartialOrd);
@@ -66,17 +67,30 @@ wrapper!(zenoh::time::Timestamp: Clone, PartialEq, PartialOrd, Hash);
 impl Timestamp {
     #[new]
     fn new(
-        time: SystemTime,
+        time: Bound<PyAny>,
         #[pyo3(from_py_with = TimestampId::from_py)] id: TimestampId,
     ) -> PyResult<Self> {
-        let timestamp = time.duration_since(SystemTime::UNIX_EPOCH).into_pyres()?;
-        Ok(Self(zenoh::time::Timestamp::new(timestamp.into(), id.0)))
+        let ntp = if let Ok(time) = time.downcast::<PyDateTime>() {
+            time.extract::<SystemTime>()?
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .into_pyres()?
+                .into()
+        } else if let Ok(ntp) = time.extract::<NTP64>() {
+            ntp.0
+        } else {
+            return Err(PyTypeError::new_err("expected a `datetime` or a `NTP64`"));
+        };
+        Ok(Self(zenoh::time::Timestamp::new(ntp, id.0)))
     }
 
     fn get_time(&self) -> SystemTime {
         self.0.get_time().to_system_time()
     }
 
+    fn get_time_as_ntp64(&self) -> NTP64 {
+        (*self.0.get_time()).into()
+    }
+
     fn get_id(&self) -> TimestampId {
         (*self.0.get_id()).into()
     }
@@ -123,3 +137,69 @@ impl Timestamp {
         format!("{}", self.0)
     }
 }
+
+wrapper!(zenoh::time::NTP64: Clone, PartialEq, PartialOrd, Hash);
+
+#[pymethods]
+impl NTP64 {
+    #[new]
+    fn new(seconds: u64, nanoseconds: u32) -> Self {
+        Self(Duration::new(seconds, nanoseconds).into())
+    }
+
+    fn as_secs_f64(&self) -> f64 {
+        self.0.as_secs_f64()
+    }
+
+    fn as_secs(&self) -> u32 {
+        self.0.as_secs()
+    }
+
+    fn as_nanos(&self) -> u64 {
+        self.0.as_nanos()
+    }
+
+    fn subsec_nanos(&self) -> u32 {
+        self.0.subsec_nanos()
+    }
+
+    fn to_datetime(&self) -> SystemTime {
+        SystemTime::UNIX_EPOCH + self.0.to_duration()
+    }
+
+    fn to_string_rfc3339_lossy(&self) -> String {
+        self.0.to_string_rfc3339_lossy()
+    }
+
+    #[classmethod]
+    fn parse_rfc3339(_cls: &Bound<PyType>, s: &str) -> PyResult<Self> {
+        zenoh::time::NTP64::parse_rfc3339(s)
+            .map(Self)
+            .map_err(|err| err.cause.into_pyerr())
+    }
+
+    fn __richcmp__(&self, other: &Self, op: pyo3::pyclass::CompareOp) -> bool {
+        match op {
+            pyo3::pyclass::CompareOp::Lt => self < other,
+            pyo3::pyclass::CompareOp::Le => self <= other,
+            pyo3::pyclass::CompareOp::Eq => self == other,
+            pyo3::pyclass::CompareOp::Ne => self != other,
+            pyo3::pyclass::CompareOp::Gt => self > other,
+            pyo3::pyclass::CompareOp::Ge => self >= other,
+        }
+    }
+
+    fn __hash__(&self) -> u64 {
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        self.0.hash(&mut hasher);
+        hasher.finish()
+    }
+
+    fn __repr__(&self) -> String {
+        format!("{:?}", self.0)
+    }
+
+    fn __str__(&self) -> String {
+        format!("{}", self.0)
+    }
+}

zenoh/__init__.pyi

@@ -574,6 +574,49 @@ class LivelinessToken:
     def undeclare(self):
         """Undeclare the :class:`LivelinessToken`."""
 
+@final
+class NTP64:
+    """A NTP 64-bits format as specified in RFC-5909 <https://tools.ietf.org/html/rfc5905#section-6>
+
+    The 1st 32-bits part is the number of second since the EPOCH of the physical clock,
+    and the 2nd 32-bits part is the fraction of second."""
+
+    def __new__(cls, seconds: int, nanos: int) -> Self: ...
+    def as_secs_f64(self) -> float:
+        """Returns this NTP64 as a f64 in seconds.
+
+        The integer part of the f64 is the NTP64's Seconds part.
+        The decimal part of the f64 is the result of a division of NTP64's Fraction part divided by 2^32.
+        Considering the probable large number of Seconds (for a time relative to UNIX_EPOCH), the precision of the resulting f64 might be in the order of microseconds.
+        Therefore, it should not be used for comparison. Directly comparing [NTP64] objects is preferable.
+        """
+
+    def as_secs(self) -> int:
+        """Returns the 32-bits seconds part."""
+
+    def as_nanos(self) -> int:
+        """Returns the total duration converted to nanoseconds."""
+
+    def subsec_nanos(self) -> int:
+        """Returns the 32-bits fraction of second part converted to nanoseconds."""
+
+    def to_datetime(self) -> datetime:
+        """Returns this NTP64 as a datetime."""
+
+    def to_string_rfc3339_lossy(self) -> str:
+        """Convert to a RFC3339 time representation with nanoseconds precision.
+
+        e.g.: `"2024-07-01T13:51:12.129693000Z"``"""
+
+    @classmethod
+    def parse_rfc3339(cls, s: str) -> Self:
+        """Parse a RFC3339 time representation into a NTP64."""
+
+    def __eq__(self, other: Any) -> bool: ...
+    def __ge__(self, other) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __str__(self) -> str: ...
+
 @final
 class Parameters:
     """A collection of key-value parameters used in query operations.
@@ -1723,10 +1766,13 @@ class Timestamp:
     For detailed information about Timestamp, see: https://docs.rs/zenoh/latest/zenoh/time/struct.Timestamp.html
     """
 
-    def __new__(cls, time: datetime, id: _IntoTimestampId) -> Self: ...
+    def __new__(cls, time: datetime | NTP64, id: _IntoTimestampId) -> Self: ...
     def get_time(self) -> datetime:
         """Returns the time component of the timestamp as a datetime object."""
 
+    def get_time_as_ntp64(self) -> NTP64:
+        """Returns the time component of the timestamp as a datetime object."""
+
     def get_id(self) -> TimestampId:
         """Returns the unique identifier component of the timestamp as a :class:`TimestampId`."""