Support exceptions in Python

.github/workflows/python.yml

@@ -126,7 +126,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.10'
+          python-version: '3.11'
       - name: Build wheels
         uses: PyO3/maturin-action@v1
         with:
@@ -138,14 +138,6 @@ jobs:
         with:
           name: wheels-macos-${{ matrix.platform.target }}
           path: dist
-      - name: pytest
-        if: ${{ !startsWith(matrix.platform.target, 'aarch64') }}
-        shell: bash
-        run: |
-          set -e
-          pip install hifitime --find-links dist --force-reinstall --no-index -vv
-          pip install pytest
-          pytest
 
   sdist:
     runs-on: ubuntu-latest

src/duration/kani_verif.rs

@@ -43,7 +43,9 @@ fn formal_duration_truncated_ns_reciprocity() {
         // Then it does not fit on a i64, so this function should return an error
         assert_eq!(
             dur_from_part.try_truncated_nanoseconds(),
-            Err(DurationError::Overflow)
+            Err(Err(EpochError::Duration {
+                source: DurationError::Overflow,
+            }))
         );
     } else if centuries == -1 {
         // If we are negative by just enough that the centuries is negative, then the truncated seconds

src/python.rs

@@ -8,21 +8,82 @@
  * Documentation: https://nyxspace.com/
  */
 
-use pyo3::{exceptions::PyException, prelude::*};
+use pyo3::{
+    exceptions::{PyBaseException, PyException},
+    prelude::*,
+    types::{PyDict, PyTuple},
+};
 
 use crate::leap_seconds::{LatestLeapSeconds, LeapSecondsFile};
 use crate::prelude::*;
 use crate::ut1::Ut1Provider;
 
+// Keep the module at the top
+#[pymodule]
+fn hifitime(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<Epoch>()?;
+    m.add_class::<TimeScale>()?;
+    m.add_class::<TimeSeries>()?;
+    m.add_class::<Duration>()?;
+    m.add_class::<Unit>()?;
+    m.add_class::<LatestLeapSeconds>()?;
+    m.add_class::<LeapSecondsFile>()?;
+    m.add_class::<Ut1Provider>()?;
+    m.add_class::<PyEpochError>()?;
+    m.add_class::<PyDurationError>()?;
+    m.add_class::<PyParsingError>()?;
+    Ok(())
+}
+
+#[pyclass]
+#[pyo3(name = "EpochError", extends = PyBaseException)]
+pub struct PyEpochError {}
+
+#[pymethods]
+impl PyEpochError {
+    #[new]
+    #[pyo3(signature = (*_args, **_kwargs))]
+    fn new(_args: Bound<'_, PyTuple>, _kwargs: Option<Bound<'_, PyDict>>) -> Self {
+        Self {}
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "ParsingError", extends = PyBaseException)]
+pub struct PyParsingError {}
+
+#[pymethods]
+impl PyParsingError {
+    #[new]
+    #[pyo3(signature = (*_args, **_kwargs))]
+    fn new(_args: Bound<'_, PyTuple>, _kwargs: Option<Bound<'_, PyDict>>) -> Self {
+        Self {}
+    }
+}
+
+#[pyclass]
+#[pyo3(name = "DurationError", extends = PyBaseException)]
+pub struct PyDurationError {}
+
+#[pymethods]
+impl PyDurationError {
+    #[new]
+    #[pyo3(signature = (*_args, **_kwargs))]
+    fn new(_args: Bound<'_, PyTuple>, _kwargs: Option<Bound<'_, PyDict>>) -> Self {
+        Self {}
+    }
+}
+
+// convert you library error into a PyErr using the custom exception type
 impl From<EpochError> for PyErr {
-    fn from(err: EpochError) -> PyErr {
-        PyException::new_err(err.to_string())
+    fn from(err: EpochError) -> Self {
+        PyErr::new::<PyEpochError, _>(err.to_string())
     }
 }
 
 impl From<ParsingError> for PyErr {
     fn from(err: ParsingError) -> PyErr {
-        PyException::new_err(err.to_string())
+        PyErr::new::<PyParsingError, _>(err.to_string())
     }
 }
 
@@ -31,16 +92,3 @@ impl From<DurationError> for PyErr {
         PyException::new_err(err.to_string())
     }
 }
-
-#[pymodule]
-fn hifitime(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add_class::<Epoch>()?;
-    m.add_class::<TimeScale>()?;
-    m.add_class::<TimeSeries>()?;
-    m.add_class::<Duration>()?;
-    m.add_class::<Unit>()?;
-    m.add_class::<LatestLeapSeconds>()?;
-    m.add_class::<LeapSecondsFile>()?;
-    m.add_class::<Ut1Provider>()?;
-    Ok(())
-}

tests/python/test_epoch.py

@@ -1,4 +1,4 @@
-from hifitime import Epoch, TimeSeries, Unit, Duration
+from hifitime import Duration, Epoch, EpochError, ParsingError, TimeSeries, Unit
 from datetime import datetime
 import pickle
 
@@ -19,6 +19,13 @@ def test_strtime():
 
     assert pickle.loads(pickle.dumps(epoch)) == epoch
 
+    try:
+        epoch.strftime("%o")
+    except ParsingError as e:
+        print(f"caught {e}")
+    else:
+        raise AssertionError("failed to catch parsing error")
+
 
 def test_utcnow():
     epoch = Epoch.system_now()
@@ -67,3 +74,11 @@ def test_duration_eq():
 
     dur = Duration("37 min 26 s")
     assert pickle.loads(pickle.dumps(dur)) == dur
+
+def test_exceptions():
+    try:
+        Epoch("invalid")
+    except EpochError as e:
+        print(f"caught {e}")
+    else:
+        raise AssertionError("failed to catch epoch error")