refactor: replace time with jiff

Also updates the `timedatectl` example from `chrono` to `jiff`.

Cargo.toml

@@ -23,7 +23,7 @@ futures-channel = "0.3.31"
 futures-util = "0.3.31"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0"
-time = { version = "0.3", features = ["parsing"] }
+jiff = "0.2"
 tracing = "0.1.41"
 zbus = { version = "5.11.0" }
 zvariant = { version = "5.7.0" }

mpris2/Cargo.toml

@@ -9,7 +9,7 @@ license = "MPL-2.0"
 futures-util.workspace = true
 serde.workspace = true
 thiserror.workspace = true
-time.workspace = true
+jiff.workspace = true
 zbus.workspace = true
 zvariant.workspace = true
 

mpris2/examples/list.rs

@@ -43,7 +43,7 @@ async fn main() -> Result<()> {
 			.await
 			.into_diagnostic()
 			.wrap_err_with(|| format!("Failed to get position for media player '{}'", name))?
-			.map(|s| format!("{} seconds", s.as_seconds_f32()))
+			.map(|s| format!("{} seconds", s.as_secs_f32()))
 			.unwrap_or_else(|| "N/A".to_owned());
 		println!("\tPosition: {}", position);
 		if !player

mpris2/src/metadata.rs

@@ -1,11 +1,11 @@
 // SPDX-License-Identifier: MPL-2.0
 use crate::error::{Error, Result};
+use jiff::{SignedDuration, Timestamp};
 use std::{
 	collections::HashMap,
 	fmt,
 	ops::{Deref, DerefMut},
 };
-use time::{Duration, OffsetDateTime};
 use zbus::zvariant::{OwnedObjectPath, Value as ZValue};
 
 #[derive(Debug, Clone, PartialEq)]
@@ -90,7 +90,7 @@ impl Metadata {
 	}
 
 	/// `xesam:contentCreated`: When the track was created. Usually only the year component will be useful.
-	pub fn created(&self) -> Option<OffsetDateTime> {
+	pub fn created(&self) -> Option<Timestamp> {
 		self.inner
 			.get("xesam:contentCreated")
 			.cloned()
@@ -106,7 +106,7 @@ impl Metadata {
 	}
 
 	/// `xesam:firstUsed`: When the track was first played.
-	pub fn first_played(&self) -> Option<OffsetDateTime> {
+	pub fn first_played(&self) -> Option<Timestamp> {
 		self.inner
 			.get("xesam:firstUsed")
 			.cloned()
@@ -128,7 +128,7 @@ impl Metadata {
 	}
 
 	/// `xesam:lastUsed`: When the track was last played.
-	pub fn last_played(&self) -> Option<OffsetDateTime> {
+	pub fn last_played(&self) -> Option<Timestamp> {
 		self.inner
 			.get("xesam:lastUsed")
 			.cloned()
@@ -199,7 +199,7 @@ impl Metadata {
 	}
 
 	/// `mpris:length`: The length of the track in microseconds.
-	pub fn length(&self) -> Option<Duration> {
+	pub fn length(&self) -> Option<SignedDuration> {
 		self.inner
 			.get("mpris:length")
 			.cloned()
@@ -209,7 +209,7 @@ impl Metadata {
 				MetadataValue::Str(s) => s.parse().ok(),
 				_ => None,
 			})
-			.map(Duration::microseconds)
+			.map(SignedDuration::from_micros)
 	}
 
 	/// `mpris:artUrl`: The location of an image representing the track or album.
@@ -309,17 +309,13 @@ impl MetadataValue {
 
 	/// Tries to extract a date/time from the variant,
 	/// returning an error if the variant is not a date/time.
-	pub fn try_into_date(self) -> Result<OffsetDateTime> {
+	pub fn try_into_date(self) -> Result<Timestamp> {
 		let variant = self.variant();
 		match self {
-			MetadataValue::Str(s) => {
+			MetadataValue::Str(s) => s.parse::<Timestamp>().map_err(|_| Error::IncorrectVariant {
-				OffsetDateTime::parse(&s, &time::format_description::well_known::Rfc3339).map_err(
+				wanted: "String (DateTime)",
-					|_| Error::IncorrectVariant {
+				actual: variant,
-						wanted: "String (DateTime)",
+			}),
-						actual: variant,
-					},
-				)
-			}
 			_ => Err(Error::IncorrectVariant {
 				wanted: "String (DateTime)",
 				actual: variant,
@@ -329,7 +325,7 @@ impl MetadataValue {
 
 	/// Tries to extract a date/time from the variant,
 	/// panicking if the variant is not a date/time.
-	pub fn into_date(self) -> OffsetDateTime {
+	pub fn into_date(self) -> Timestamp {
 		self.try_into_date().unwrap_or_else(|err| panic!("{}", err))
 	}
 

mpris2/src/player.rs

@@ -7,12 +7,12 @@ use crate::{
 	metadata::Metadata,
 	track::TrackId,
 };
+use jiff::SignedDuration;
 use std::{
 	fmt::{self, Display},
 	ops::Deref,
 	str::FromStr,
 };
-use time::Duration;
 use zbus::{Connection, names::OwnedBusName};
 
 #[derive(Debug, Clone)]
@@ -41,11 +41,9 @@ impl Player {
 	}
 
 	/// Seeks the specified duration.
-	pub async fn seek(&self, duration: Duration) -> Result<bool> {
+	pub async fn seek(&self, duration: SignedDuration) -> Result<bool> {
 		if self.proxy.can_seek().await? {
-			self.proxy
+			self.proxy.seek(duration.as_micros() as i64).await?;
-				.seek(duration.whole_microseconds() as i64)
-				.await?;
 			Ok(true)
 		} else {
 			Ok(false)
@@ -55,9 +53,9 @@ impl Player {
 	/// Sets the current track position.
 	///
 	/// If `track` does not match the id of the currently-playing track, the call is ignored as "stale".
-	pub async fn set_position(&self, track: &TrackId, position: Duration) -> Result<()> {
+	pub async fn set_position(&self, track: &TrackId, position: SignedDuration) -> Result<()> {
 		self.proxy
-			.set_position(track, position.whole_microseconds() as i64)
+			.set_position(track, position.as_micros() as i64)
 			.await
 			.map_err(Error::from)
 	}
@@ -65,8 +63,8 @@ impl Player {
 	/// How far into the current track the player is.
 	///
 	/// Not all players support this, and it will return None if this is the case.
-	pub async fn position(&self) -> Result<Option<Duration>> {
+	pub async fn position(&self) -> Result<Option<SignedDuration>> {
-		handle_optional(self.proxy.position().await.map(Duration::microseconds))
+		handle_optional(self.proxy.position().await.map(SignedDuration::from_micros))
 	}
 
 	/// Gets the current playback status of the player.

networkmanager/Cargo.toml

@@ -8,6 +8,6 @@ license = "MPL-2.0"
 bitflags = "2.9"
 derive_builder = "0.20.2"
 procfs = { version = "0.18", default-features = false }
-time.workspace = true
+jiff.workspace = true
 zvariant.workspace = true
 zbus.workspace = true

networkmanager/src/access_point.rs

@@ -8,14 +8,13 @@ use crate::{
 	util::clock_boottime_to_time,
 };
 use std::ops::Deref;
-use time::OffsetDateTime;
 use zbus::Result;
 
 #[derive(Debug)]
 pub struct AccessPoint<'a>(AccessPointProxy<'a>);
 
 impl<'a> AccessPoint<'a> {
-	pub async fn last_seen(&self) -> Result<Option<OffsetDateTime>> {
+	pub async fn last_seen(&self) -> Result<Option<jiff::Timestamp>> {
 		Ok(clock_boottime_to_time(self.0.last_seen().await?))
 	}
 

networkmanager/src/util.rs

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: MPL-2.0
 
-use time::OffsetDateTime;
+use jiff::Timestamp;
 
-pub fn clock_boottime_to_time(time: i32) -> Option<OffsetDateTime> {
+pub fn clock_boottime_to_time(time: i32) -> Option<Timestamp> {
 	let boot_time = procfs::boot_time_secs()
 		.ok()
 		.and_then(|boot_time| i64::try_from(boot_time).ok())?;
-	OffsetDateTime::from_unix_timestamp(boot_time + time as i64).ok()
+	Timestamp::from_second(boot_time + time as i64).ok()
 }

timedate/Cargo.toml

@@ -15,8 +15,7 @@ all-features = true
 zbus.workspace = true
 
 [dev-dependencies]
-chrono = "0.4.42"
+jiff.workspace = true
-chrono-tz = "0.10.4"
 zbus.workspace = true
 zbus.features = ["tokio"]
 

timedate/examples/timedatectl.rs

@@ -1,7 +1,7 @@
 // Copyright 2023 System76 <info@system76.com>
 // SPDX-License-Identifier: MPL-2.0
 
-use chrono::TimeZone;
+use jiff::{Timestamp, tz::TimeZone};
 
 const TZ_FORMAT: &str = "%a %Y-%m-%d %H:%M:%S %Z";
 const RTC_FORMAT: &str = "%a %Y-%m-%d %H:%M:%S";
@@ -23,21 +23,24 @@ pub async fn main() -> zbus::Result<()> {
 	let time_usecs = proxy.time_usec().await?;
 	let timezone = proxy.timezone().await?;
 
-	let tz: chrono_tz::Tz = timezone.parse().unwrap();
+	let tz = TimeZone::get(&timezone).unwrap();
+	let utc = TimeZone::UTC;
 
-	let datetime = tz.timestamp_millis_opt((time_usecs / 1000) as i64).unwrap();
+	let datetime = Timestamp::from_microsecond(time_usecs as i64)
+		.unwrap()
+		.to_zoned(tz.clone());
 
-	let rtc_millis = (rtc_time_usecs / 1000) as i64;
+	let rtc_ts = Timestamp::from_microsecond(rtc_time_usecs as i64).unwrap();
 	let rtc_time = (if rtc_in_local {
-		tz.timestamp_millis_opt(rtc_millis).unwrap()
+		rtc_ts.to_zoned(tz)
 	} else {
-		chrono_tz::UTC.timestamp_millis_opt(rtc_millis).unwrap()
+		rtc_ts.to_zoned(utc.clone())
 	})
-	.format(RTC_FORMAT);
+	.strftime(RTC_FORMAT);
 
-	let local = datetime.format(TZ_FORMAT);
+	let local = datetime.strftime(TZ_FORMAT);
-	let universal = datetime.with_timezone(&chrono_tz::UTC).format(TZ_FORMAT);
+	let universal = datetime.with_time_zone(utc).strftime(TZ_FORMAT);
-	let tz_string = datetime.format("%Z, %z");
+	let tz_string = datetime.strftime("%Z, %z");
 
 	let rtc_in_local = CHOICES[usize::from(rtc_in_local)];
 	let synchronized = CHOICES[usize::from(proxy.ntp_synchronized().await.unwrap_or_default())];