- replace anyhow by thiserror

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ome-metadata"
-version = "0.2.2"
+version = "0.3.0"
 edition = "2024"
 rust-version = "1.85.1"
 authors = ["Wim Pomp <w.pomp@nki.nl>"]
@@ -19,10 +19,10 @@ name = "ome_metadata"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-anyhow = "1.0.98"
 enum-utils = "0.1.2"
 serde = { version = "1.0.219", features = ["derive"] }
-quick-xml = {  version = "0.37.5", features = ["serialize"] }
+thiserror = "2.0.16"
+quick-xml = { version = "0.38.0", features = ["serialize"] }
 
 [dependencies.pyo3]
 version = "0.24.2"

src/error.rs

@@ -0,0 +1,14 @@
+use quick_xml::DeError;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("io error: {0}")]
+    IO(#[from] std::io::Error),
+    #[error("serde error: {0}")]
+    SerdeXml(#[from] DeError),
+    #[error("size of {0} is unknown")]
+    SizeOfUnknown(String),
+    #[error("no conversion to K by multiplication only")]
+    TemparatureConversion,
+}

src/lib.rs

@@ -1,10 +1,11 @@
 #![allow(non_camel_case_types)]
 pub mod ome;
 
+mod error;
 #[cfg(feature = "python")]
 mod py;
 
-use anyhow::{Error, Result};
+use crate::error::Error;
 pub use ome::Ome;
 use quick_xml::de::from_str;
 use std::str::FromStr;
@@ -12,7 +13,7 @@ use std::str::FromStr;
 impl FromStr for Ome {
     type Err = Error;
 
-    fn from_str(s: &str) -> Result<Self> {
+    fn from_str(s: &str) -> Result<Self, Error> {
         Ok(from_str(s)?)
     }
 }
@@ -26,7 +27,7 @@ mod tests {
         ($($name:ident: $file:expr $(,)?)*) => {
             $(
                 #[test]
-                fn $name() -> Result<()> {
+                fn $name() -> Result<(), Error> {
                     let file = read_to_string(format!("tests/{}.xml", $file))?;
                     let _ome: Ome = file.parse()?;
                     Ok(())

src/ome.rs

@@ -1,4 +1,4 @@
-use anyhow::{Result, anyhow};
+use crate::error::Error;
 use enum_utils::{FromStr, IterVariants};
 #[cfg(feature = "python")]
 use pyo3::types::{PyDict, PyInt, PyString};
@@ -2762,10 +2762,10 @@ pub struct XmlAnnotationValue;
 
 pub trait Convert: PartialEq {
     /// conversion factor between this and SI value
-    fn as_si(&self) -> Result<f64>;
+    fn as_si(&self) -> Result<f64, Error>;
 
     /// convert a value with this unit into another unit
-    fn convert(&self, unit: &Self, value: f64) -> Result<f64> {
+    fn convert(&self, unit: &Self, value: f64) -> Result<f64, Error> {
         if self == unit {
             Ok(value)
         } else {
@@ -2798,7 +2798,7 @@ impl_enum_variants!(
 );
 
 impl Convert for UnitsElectricPotential {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
             UnitsElectricPotential::YV => Ok(1e24),
             UnitsElectricPotential::ZV => Ok(1e21),
@@ -2826,7 +2826,7 @@ impl Convert for UnitsElectricPotential {
 }
 
 impl Convert for UnitsFrequency {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
             UnitsFrequency::YHz => Ok(1e24),
             UnitsFrequency::ZHz => Ok(1e21),
@@ -2854,7 +2854,7 @@ impl Convert for UnitsFrequency {
 }
 
 impl Convert for UnitsLength {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
             UnitsLength::Ym => Ok(1e24),
             UnitsLength::Zm => Ok(1e21),
@@ -2888,14 +2888,14 @@ impl Convert for UnitsLength {
             UnitsLength::Ly => Ok(9.461e15),
             UnitsLength::Pc => Ok(3.086e16),
             UnitsLength::Pt => Ok(3.52778e-4),
-            UnitsLength::Pixel => Err(anyhow!("Size of pixel is unknown")),
+            UnitsLength::Pixel => Err(Error::SizeOfUnknown("pixel".to_string())),
-            UnitsLength::ReferenceFrame => Err(anyhow!("Size of reference frame is unknown")),
+            UnitsLength::ReferenceFrame => Err(Error::SizeOfUnknown("reference frame".to_string())),
         }
     }
 }
 
 impl Convert for UnitsPower {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
             UnitsPower::YW => Ok(1e24),
             UnitsPower::ZW => Ok(1e21),
@@ -2923,7 +2923,7 @@ impl Convert for UnitsPower {
 }
 
 impl Convert for UnitsPressure {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
             UnitsPressure::YPa => Ok(1e24),
             UnitsPressure::ZPa => Ok(1e21),
@@ -2962,16 +2962,16 @@ impl Convert for UnitsPressure {
 }
 
 impl Convert for UnitsTemperature {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
-            UnitsTemperature::C => Err(anyhow!("No conversion to K by multiplication only")),
+            UnitsTemperature::C => Err(Error::TemparatureConversion),
-            UnitsTemperature::F => Err(anyhow!("No conversion to K by multiplication only")),
+            UnitsTemperature::F => Err(Error::TemparatureConversion),
             UnitsTemperature::K => Ok(1e1),
             UnitsTemperature::R => Ok(5f64 / 9f64),
         }
     }
 
-    fn convert(&self, unit: &Self, value: f64) -> Result<f64> {
+    fn convert(&self, unit: &Self, value: f64) -> Result<f64, Error> {
         match (self, unit) {
             (UnitsTemperature::F, UnitsTemperature::C) => Ok((value - 32.) * 5. / 9.),
             (UnitsTemperature::K, UnitsTemperature::C) => Ok(value - 273.15),
@@ -2991,7 +2991,7 @@ impl Convert for UnitsTemperature {
 }
 
 impl Convert for UnitsTime {
-    fn as_si(&self) -> Result<f64> {
+    fn as_si(&self) -> Result<f64, Error> {
         match self {
             UnitsTime::Ys => Ok(1e24),
             UnitsTime::Zs => Ok(1e21),

src/py.rs

@@ -1,12 +1,11 @@
 use crate::Ome;
 use crate::ome::{
-    Convert, UnitsElectricPotential, UnitsFrequency, UnitsLength, UnitsPower,
+    Convert, UnitsElectricPotential, UnitsFrequency, UnitsLength, UnitsPower, UnitsPressure,
-    UnitsPressure, UnitsTemperature, UnitsTime,
+    UnitsTemperature, UnitsTime,
 };
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 
-
 macro_rules! impl_enum_into_py_object {
     ($($s:ident: $t:ty $(,)?)*) => {
         $(
@@ -28,7 +27,7 @@ macro_rules! impl_enum_into_py_object {
                 /// convert a value between units
                 fn convert(&self, unit: &str, value: f64) -> PyResult<f64> {
                     match unit.parse() {
-                        Ok(unit) => Ok(self.inner.convert(&unit, value)?),
+                        Ok(unit) => Ok(self.inner.convert(&unit, value).map_err(|e| PyErr::new::<PyValueError, _>(format!("{}", e)))?),
                         Err(_) => Err(PyErr::new::<PyValueError, _>(format!("Invalid unit: {}", unit)))
                     }
                 }
@@ -87,7 +86,8 @@ fn ome_metadata_rs(m: &Bound<'_, PyModule>) -> PyResult<()> {
 
     #[pyfn(m)]
     fn ome(text: &str) -> PyResult<Ome> {
-        Ok(text.parse()?)
+        text.parse()
+            .map_err(|e| PyErr::new::<PyValueError, _>(format!("{}", e)))
     }
 
     Ok(())